Operating System Overview – Concepts and Architectures

Recommendation: implement a tiny scheduler in a revamped kernel running in a VM to observe how processes, memory, and I/O interact. Track update cycles and compare metrics across monolithic and microkernel approaches using the guides and practical utilities to hold ground on the core ideas. Grab a coffee and run the first experiment to build a reliable baseline.

We cover the fundamentals: process lifecycles, threads, CPU scheduling, memory management, I/O paths, and device management via drivers. The material emphasizes observability through utilities such as ps, top, and strace. For storage and file systems, compare ext4, XFS, and btrfs under load, measuring throughput and latency across RAM disks, SSDs, and networked storage devices to inform design trade-offs.

The architectures section contrasts monolithic, microkernel, and hybryd designs. Through practical examples, compare how each approach handles system calls, interrupts, and driver models. A monolithic kernel centralizes many services; a microkernel isolates services and uses IPC; a revamped hybryd blends performance with modularity. Review memory management units, page tables, and TLBs across x86_64 and ARM, highlighting differences in address translation and cache behavior.

For engineers and students, practical steps matter: define a target device and the workload profile (interactive, batch, or real-time), then run a suite of tests to evaluate latency and throughput. Start with a minimal footprint on embedded devices; scale up to desktop scenarios, and document results in guides so others can reproduce. Use PCIe devices to test drivers and update your notes with measured data in a structured format.

In practice, this overview helps you map how software holds together hardware through software layers and provides a concrete path for learning. Choose to explore kernel internals, file systems, or virtualization, and use the guides to extend the coverage. Keep notes, collect metrics, and iterate your experiments with a new hardware update to keep the study fresh.

OS Concepts and Architectures

Recommendation: Adopt a modular microkernel-inspired core to maximize isolation and customization for a wide range of tasks. This approach helps travelers deploy lightweight services in user space, roll out updates quickly, and easy-to-customize components where they are most needed. Use an overview which compares options, and refer to a reliable guide such as carlsoncnet for deeper data. For UI, provide captions and support double-tap interactions to improve accessibility and speed up time-to-task completion. A white theme and concise, language-aware messages help users tell the system what they want and get helpful responses in seconds.

Core concepts include process isolation, memory management models, and IPC. Monolithic kernels keep services in a single address space, enabling fast system calls but increasing the blast radius if a driver fails. Microkernels keep only essential services in the kernel and move others to user space, supporting customization and safer testing, but with IPC overhead. Hybrid designs aim to balance both sides, delivering stronger fault containment with lower latency than pure microkernels. Exokernels push resource management to applications, which can unlock near-metal performance if developers provide abstractions in languages such as C, Rust, or safer runtimes; this approach remains common in research and specialized deployments.

CS and OS teams can use this guide to plan implementation steps: if you need quick task switching and strong safety, lean toward microkernel or hybrid designs; if you prioritize maximum throughput on uniform hardware, a monolithic approach may pay off. Track spatial locality, turn complexity into reusable libraries, and define clear APIs for drivers and services. For travelers and engineers alike, this approach translates into faster support, easier upgrades, and clearer test coverage.

Process Management: Scheduling, Context Switching, and Concurrency

Configure Round Robin with a 16-32 ms quantum for interactive tasks to keep latency predictable. In a multi-core environment, assign I/O-bound processes to separate cores to improve cache locality and keep the ready queue bank balanced across multiple cores.

Beyond RR, use ticket-based scheduling to ensure probabilistic fairness, and layer a multilevel feedback queue (MLFQ) that can adapt to changing workloads over years. First, split queues into multiple levels, letting short CPU bursts climb to higher levels while longer tasks stay in lower ones. With a landmark approach, assign foreground tasks to a high-priority line while background work circulates in a lower tier. youll observe improved responsiveness as workloads shift between groups.

Context switching introduces overhead when the CPU saves and restores state across tasks. On real systems, overhead ranges from a few hundred cycles to a few thousand cycles; on modern CPUs this is often a few microseconds if caches and TLBs are warmed. Minimize by reducing lock duration, avoiding kernel/user-mode toggles in hot paths, and choosing lightweight synchronization primitives like spinlocks in tight loops where appropriate. Consider packing related data to stay within the same cache line; this reduces misses and improves the line’s efficiency. You can remove unnecessary preemption by bypassing heavy kernel transitions via fast user-space paths or similar techniques.

Concurrency requires safe access to shared resources: protect with mutexes, semaphores, or lock-free data structures. Avoid deadlocks by ordering lock acquisition and using timeouts. Use fine-grained locks to reduce contention, or redesign critical sections to minimize shared state. For predictable behavior, coordinate a group of worker threads that pull tasks from a shared pool, ensuring each resource is acquired in a consistent order. This approach aligns with the Источник information in your toolkit.

Monitor key metrics: context-switch count, queue lengths, and quantum utilization per priority. Collect data over hundreds of thousands of events to compute latency distributions. Maintain a newsletter with a concise weekly summary of changes and their effect on potential latency. Use a simple check to confirm that available CPU time matches targets, and remove scheduling bottlenecks that inflate away time spent in queues.

To translate theory into practice, think in terms of a bank of ready tasks, a ticket queue, and a travel-friendly profile for latency. Keep a packing list of configurations: quantum value, number of ready-queues, and per-group affinity. Your system can be tuned by a few knobs and a small set of experiments; this ability lets you land on a stable, scalable baseline that serves as a landmark for future work. Источник information can guide your decisions as you optimize the pipeline for real workloads, yourself gaining confidence with each iteration.

Memory Management: Paging, Protection, and Virtual Addressing

Enable paging with a two-level page table and a Translation Lookaside Buffer (TLB) to keep address translation fast and predictable. Configure a 4 KB page size to balance locality and page-table overhead. This must be complemented by a robust protection scheme and a clear virtual-addressing structure that the kernel can rely on.

An overview of paging explains how the system maps virtual pages to physical frames. The virtual address splits into a page-number and an offset; the page table lists the frame index for each page. The TLB caches recent translations to avoid walking the page table every time, and a page fault handler fills missing mappings from disk or backing store as needed.

Protection focuses on access rights and modes. Page table entries include read, write, and execute bits, plus a present bit. The CPU switches between user and supervisor modes to prevent user code from corrupting kernel data. When a process attempts an invalid access, the hardware raises a fault and the OS executes a fault handler to terminate or adjust permissions. This control keeps full separation between processes. This help guides operators toward safer tuning and easier debugging.

In virtual addressing, the virtual address consists of a page-number and an offset. The hardware uses the page number to index the paged page table and the offset to locate the data within the frame. Page tables can be hierarchical (multi-level) or inverted; a TLB miss triggers a walk through the levels, and if no valid mapping exists, the OS handles a page fault, loading data from backing storage and updating the mapping. In windowing and media workloads, keeping translations fast reduces display stalls and helps interactive apps stay responsive. Platforms such as watchOS use the same protection concepts, while drivers for bluetooth and display run in controlled modes to maintain stability and security.

Performance hinges on managing the working set to avoid thrashing. Choose a page-replacement policy such as CLOCK or an LRU approximation, and keep the active set in RAM; use prefetching when access patterns are predictable. If memory is full, the OS trims nonessential pages and may swap out rarely used data. A simplified starter design works as a baseline and can evolve toward a more dynamic policy. The go-to approach for embedded devices prioritizes predictable latency over perfect caching and favors smaller, stable page tables in constrained environments.

Create a practical memory-management plan and a go-to troubleshooting checklist. Build an overview that focuses on those core tasks: configure paging with 4 KB pages, tune the TLB, and enforce protected modes while monitoring access patterns. Use a simplified page-table structure where appropriate and retain strong control over permissions. Include a summary of metrics like TLB hit rate, page-fault rate, and active-set size. In real-world deployments, those metrics matter for devices running watchOS, bluetooth, and display drivers, as well as media workloads. carlson notes that a focused approach reduces disturb to user-facing tasks. For global teams, provide email alerts and a newsletter to operators when thresholds are exceeded, and tailor the notices to locales such as france and australia. The display must remain responsive, windowing must stay smooth, and the system should create a stable environment that those teams can rely on. Instead of chasing every micro-optimization, prioritize predictable latency and full isolation of processes to prevent cross-process disturbances.

Kernel Architectures: Monolithic, Microkernel, and Hybrid Designs

Àwọn ìmọ̀ràn: Start with a brand-new hybrid kernel for most desktop and server deployments to balance speed, reliability, and modularity.

Monolithic kernels keep drivers and core services inside the kernel, minimizing context switches and IPC overhead. This yields strong raw throughput for general workloads and simpler toolchains, with immediate access to အသုံးအဆောင်များ and filesystems. The approach typically provides lower latency for windowing interactions and real-time input handling, but one bug in a driver can crash the entire kernel, affecting availability and complicating updates. In practice, popular Linux distributions adopt this model with a broad hardware ecosystem, including support for routine folders and vast software repositories.

Microkernels place most services in user space and rely on a small, well-defined kernel for inter-process communication and resource management. This design improves fault isolation and security, enabling safer updates and easier formal verification for critical components. However, IPC and context switching costs are higher, leading to longer response times for I/O and display pipelines on older implementations. Real-world figures vary, but microkernel IPC can add noticeable overhead compared with monolithic paths, especially under heavy multitasking. Still, projects such as seL4 na MINIX 3 demonstrate robust reliability for safety-sensitive applications.

Hybrid kernels blend the benefits of both worlds by running a compact core while keeping selected drivers and services in kernel space or as flexible user-space modules. This model supports high throughput where it matters and strong isolation where it helps, delivering a ala itan na simplified compromise for mainstream OS like XNU (macOS and iOS) and later kernel families. In practice, a hybrid design can enable rapid driver iteration, simplified maintenance, and better compatibility with legacy interfaces, while preserving security boundaries and smoother updates.

Practical guidelines to choose and deploy: analyze ndụ-cycle data and production workloads; examine availability of device drivers, အသုံးအဆောင်များ, and user-space services; verify translation na нууггаа localization support and windowing requirements for GUI environments; review the ọ̀nà map for future updates and driver changes; plan sharing na saving of critical state across components; ensure youre systems are enabled with robust update mechanisms and folders-based packaging in folders; if youre in Falanse or another region, tailor builds to locale needs and maintain a brand-new baseline to avoid drift. This approach reduces downtime and improves long-term reliability.

In short, monolithic, microkernel, and hybrid designs each have strengths and trade-offs; align your choice with workload, security, and maintenance goals, then monitor metrics and adjust accordingly to sustain robust operations, as new features appears and maturity grows.

Storage and File Systems: Journaling, Cache Strategies, and Reliability

Enable metadata journaling on your system to protect a document during power loss. youll find this reduces recovery time after a crash and keeps task metadata consistent.

Journaling basics and practical choices:

• Mode selection: metadata-only, data+metadata, or full data journaling. For most tasks, metadata-only offers faster replay while data+metadata helps keep app data safer.
• Enable fsync and barriers on the mount options to ensure critical writes are flushed to durable storage.
• Platform choices: EXT4, XFS, Btrfs, and ZFS provide built-in journaling with checksums and consistent metadata updates.
• Preview and monitor: run periodic fsck checks after unclean shutdowns; youll find a quick check repair often restores consistency with minimal downtime.

Cache strategies to boost throughput without sacrificing reliability:

• RAM cache gbɔŋ gbɔŋ gbɔŋ gbɔŋ leŋŋ; kpɔŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋ, gbɔŋ leŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋ, nɔŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋŋ.
• கொள்கை எழுதுதல்: எழுதுதல்-நேரடியாக மின் தடை ஏற்பட்டால் தரவு இழப்பைக் குறைக்கிறது; திரும்ப எழுதுதல் செயல்திறனை அதிகரிக்கிறது ஆனால் நம்பகமான தற்காலிக சேமிப்பு அல்லது யுபிஎஸ் தேவைப்படுகிறது.
• Pengaturan baca-depan membantu beban kerja berurutan (seperti mempratinjau media) sementara untuk beban kerja acak, Anda dapat mengurangi pengambilan-awal untuk menghindari polusi tembolok.
• Yà gbɔ̌n ɖeɖɛ gbɔn do nú gbɛtɔ́ lɛɛ kpódó gbɛtɔ́ lɛɛ sín gbɛɖótɔ́ lɛɛ kpó hwenu e é sixú nyɔ́ ɖó gbɔn é; é nɔ gbɔn mɔ̌ dó ɖe gbɔjɛ gbɔn nú gbɛɖótɔ́ lɛɛ wu gbɔn azɔ̌ syɛ́nsyɛ́n lɛɛ mɛ ɖi wlánwlán ɖeɖɛ dó gbɛtɔ́ sín gbɛtɔ́ sín gbɛɖótɔ́ lɛɛ jí alo gbɔn gbɛtɔ́ sín gbɛɖótɔ́ lɛɛ jí.
• ဝိ hardware ကိရိယာ များ (သင် ၏ ကင်မရာ မှ ရိုက်ထား ‌သော ပုံရိပ်များ ၊ ipad များ မှ ရယူ ထား သော အချက်အလက် များ (သို့) Instagram မှ backup လုပ်ထားသော အရာများ) CPU အနီး တွင် ရှိနေစေ ရန် အတွက် HDD များ၏ ရှေ့ တွင် မြန်နှုန်းမြင့် SSD cache layer ကို စဉ်းစား ကြည့်ပါ။ ဤသည်မှာ အိမ်သုံး NAS setup များ နှင့် server ငယ်များ တွင် အတွေ့ရများပါသည်။.

Teknologi budi pekerti gbụsị na usoro ị ga-emeli taa:

• අතිරික්තය: තීරණාත්මක වෙළුම් සඳහා RAID-1 හෝ RAID-10 භාවිත කරන්න; වැදගත් ලේඛන සඳහා තනි-තැටි ගබඩාවෙන් වළකින්න; විශාල RAID5/6 අරා සමඟ URE අවදානම් ගැන දැනුවත් වන්න.
• Pārbaudes summas un datu integritāte: iespējojiet ZFS vai Btrfs datu pārbaudes summas; veiciet skrubēšanu reizi mēnesī un pēc avārijas, lai atklātu klusu korupciju.
• ພາບรวมໄວແລະສຳເນົາເມື່ອຂຽນ: ນຳໃຊ້ພາບລວມໄວຂອງລະບົບໄຟລ໌ເພື່ອເກັບກຳສະພາບພື້ນຖານກ່ອນການຍົກລະດັບ, ການແບ່ງປັນການອັບເດດ, ຫຼືການຕິດຕັ້ງ; ເກັບຮັກສາພາບລວມໄວໃນພູລ ຫຼືອຸປະກອນແຍກຕ່າງຫາກເພື່ອປ້ອງກັນຄວາມລົ້ມເຫຼວຂອງດິດຫຼັກ.
• Ti védelem: csatlakoztassa a meghajtókat egy UPS-hez; győződjön meg róla, hogy a vezérlőkön lévő cache akkumulátorral van ellátva, ha rendelkezésre áll, hogy egy váratlan áramszünet ne veszítse el az utolsó írásokat.
• အားလုံးမိတ္တူကူးပြီး စမ်းသပ်ခြင်း- ပြင်ပကူးယူမှုများကို ထိန်းသိမ်းပြီး ပြန်လည်ရယူခြင်းစမ်းသပ်မှုများကို လုပ်ဆောင်ပါ။ ကူးယူမှုများသည် သီးခြားစာရွက်စာတမ်းတစ်ခု သို့မဟုတ် ထိုပစ္စည်းများပါ၀င်သည့် ဖိုဒါတစ်ခု (ကင်မရာမှဓာတ်ပုံများ၊ မှတ်စုများနှင့် စာသားဖိုင်များ) ကို ပြန်လည်ရယူခြင်းကို အထောက်အပံ့ပေးကြောင်း မှတ်သားပါ။.

Ama ndị ọzọ ị ga-achọ ịmara maka ọnọdụ ndị e nwere ike ịzụfeta:

• Ọ bụrụ na ị na-elekọta obere ihe eji arụ n’ụlọ (ụlọ, ụgbọ ala nwere ike ịrụ CarPlay, na ngwaọrụ ndị dị nso dị ka iPad) ị nwere ike idowe data nkekọrịta kacha arụ ọrụ na ụzọ ebe nchekwa ngwa ngwa, na-ebelata latency maka ndị na-ede ma ọ bụ na-agụ ihe edeturu na ederede site n'ụzọ ma ọ bụ n'ime ụlọ ezumike.
• Maka ndị na-ese foto na ndị okike, mbụ igwefoto na edezi kwesịrị iji usoro faịlụ dị iche, nke na-edebe akwụkwọ akụkọ nke ọma iji chebe mbụ; ị nwere ike ịchekwa nlele ma ọ bụ nṅomi na olu ndabere cache.
• Ойи, мөнөттүгэр биир бэлиэтээһини эбэтэр докумуону булуоххун наада буоллаҕына, файловай системаҕа учуонайдык оҥоһуллубут метаданнай индиэксин көрдөөһүнү түргэтэтэр, ол файллары аспаттар; бу бөҕө журнардааһын уонна кэш көрүҥүн туһата буолар.

Apple Intelligence ގެ အင်္ဂါရပ်များ: စက်တွင်း ML၊ Neural Engine၊ Core ML၊ Vision၊ သဘာဝဘာသာစကား နှင့် Siri privacy

Fa'atauvaogāina fa'amatalaga patino mai le ao e ala i le fa'aaogāina o le ML i luga o masini ma le Core ML–e taofia ai fa'amatalaga mai 'au'aunaga, fa'avaveina ai galuega, ma fa'aleleia atili ai le fa'alilolilo mo tagata uma.

• On-ayns ML ayɔɔ Neural Engine: Di modɛl dɛn rɔn komplit wan pan ayfon dɛn we de yuz Neural Engine, ɛn dɛn de mek yu gɛt smat ɛkspiriɛns we yu de kip di data fa frɔm di sɛfa dɛn; dis de mek di letɛns las smɔl smɔl ɛn i de mek i yuz smɔl injin fɔ di fot dɛn, mɛsej, ɛn ap dɛn, ɛn i de mek layf fayn fɔ ɛvri pɔsin.
• Core ML na Vision: Core ML emeso ka ọ dị mfe ibubata ụdị ML na ngwa iPhone; Vision na-ekpughe nchọpụta akara ala, njirimara ederede, ihu, na nghọta ọnọdụ, na-enyere aka ịchọpụta akara ala na foto na ajụjụ onyonyo na-anọghị n'ịntanetị na-enweghị ịnweta netwọkụ, na-enyere gị aka ịnọgide na-emepụta ihe na ojiji data dị ọcha.
• NN: On-device NLP e meku NLP na device gbɔŋlɔnŋu,ŋɔŋlɔŋ gbɔŋŋɔŋlɔŋ (ŋɔŋlɔŋŋu),ŋɔŋlɔŋŋuŋɔŋŋuŋuŋuŋɔŋŋuŋu gbɔŋŋuŋɔŋŋuŋuŋu gbɔŋŋuŋɔŋŋuŋuŋuŋuŋu gbɔŋŋuŋɔŋŋuŋuŋuŋuŋu na mi gbɔŋŋuŋɔŋŋuŋuŋuŋuŋu gbɔŋŋuŋɔŋŋuŋuŋuŋuŋu.ŋɔŋlɔŋŋuŋuŋuŋuŋɔŋŋuŋuŋuŋuŋuŋuŋɔŋŋuŋuŋuŋu, gbɔŋŋuŋɔŋŋuŋuŋuŋuŋu gbɔŋŋuŋɔŋŋuŋuŋuŋuŋuŋu gbɔŋŋuŋɔŋŋuŋuŋuŋuŋuŋu.
• ꯑꯣꯏꯅꯥ ꯊꯧꯗꯣꯡ ꯀꯌꯥ ꯃꯁꯥꯒꯤ ꯈꯨꯠꯇꯥ ꯄꯨꯗꯨꯅꯥ ꯄꯥꯡꯊꯣꯛꯂꯤ, ꯃꯁꯤꯅꯥ ꯈꯨꯋꯥꯏꯗꯥ ꯊꯥꯔꯤꯕꯗꯨ ꯍꯟꯊꯍꯜꯂꯤ; ꯅꯍꯥꯛꯅꯥ ꯁꯦꯇꯤꯡꯁꯤꯡꯗꯥ ꯗꯦꯇꯥ ꯁꯦꯌꯔ ꯇꯧꯕꯗꯨ ꯀꯟꯇ꯭ꯔꯣꯜ ꯇꯧꯏ, ꯄ꯭ꯔꯥꯏꯚꯦꯁꯤ-ꯐꯔꯁ꯭ꯠ ꯃꯣꯗꯁꯤꯡꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯃꯗꯨꯅꯥ ꯃꯔꯨꯑꯣꯏꯕꯥ ꯊꯕꯀꯁꯤꯡ ꯑꯃꯁꯨꯡ ꯅꯣꯇꯤꯐꯤꯀꯦꯁꯟ-ꯒꯤ ꯃꯔꯤ ꯂꯩꯅꯕꯥ ꯊꯧꯗꯣꯡꯁꯤꯡ ꯅꯦꯇꯋꯥꯔꯛ ꯀꯟꯅꯕꯥ ꯃꯇꯃꯗꯥ ꯐꯪꯍꯅꯕꯤꯔꯤ; ꯅꯍꯥꯛꯅꯥ ꯀꯅꯥꯒꯤ ꯗꯦꯇꯥ ꯔꯨꯠꯁꯤꯡꯅꯥ ꯂꯣꯀꯦꯜꯗꯥ ꯂꯩꯔꯒꯥ ꯀꯅꯥꯅꯥ ꯈꯨꯋꯥꯏꯗꯥ ꯆꯠꯇꯣꯏ ꯍꯥꯌꯕꯗꯨ ꯊꯥꯒꯠꯄꯤꯕꯥ ꯌꯥꯏ, ꯄ꯭ꯔꯥꯏꯚꯦꯁꯤ ꯑꯁꯤ ꯃꯔꯨꯑꯣꯏꯅꯥ ꯊꯝꯕꯥ ꯑꯃꯁꯨꯡ ꯗꯦꯇꯥ ꯍꯦꯟꯗ꯭ꯂꯤꯡꯒꯦꯗꯥ ꯋꯥꯔꯣꯜ ꯄꯤꯕꯥ꯫.
• Ngā ara whakarite e pūtake ai: Whakahōu ki te iOS hou, whakahohe i ngā āhuatanga i runga pūrere i ngā wāhi e whakaekea ana, whakamātauhia a Translate tuimotu mō ngā whakamāoritanga māmā, whakamahia a Vision mō te rapu whakaahua mā ngā tohu whenua, ā, torotoro haere i ngā taupānga e whakakahatia ana e te Core ML e whakaora wā ana mā te whakamahinga aunoa; tīmata ki tētahi mea māmā kia noho mā te whakaritenga, ā, tuhia ō mahi tino pai kia whakamahia anō i ngā wā e pukumahi ana te ao; e hikaka ana tēnei huarahi mō te hunga e hīkaka ana mō te tūmataiti.

ꯑꯄꯨꯟꯕ ꯃꯤꯠꯇꯥꯡ: ꯐꯤꯆꯔꯁꯤꯡ ꯑꯁꯤꯅꯥ ꯁꯤꯟފꯝ, ꯂꯣꯟ, ꯑꯃꯁꯨꯡ ꯌꯨꯖꯔꯒꯤ ꯋꯥꯈꯜꯂꯣꯟꯕꯨ ꯕ꯭ꯔꯥꯏꯚꯦꯠꯂꯤ ꯑꯥꯏꯐꯣꯟꯁꯤꯡꯗꯥ ꯈꯪꯕꯒꯤ ꯄꯨꯛꯅꯤꯡ ꯆꯤꯡꯁꯤꯟꯅꯤꯡꯉꯥꯏ ꯑꯣꯏꯕꯥ ꯄꯥꯝꯕꯩ ꯑꯃꯥ ꯄꯤꯔꯤ꯫ ꯁꯨꯏꯠ ꯑꯁꯤꯅꯥ ꯄꯥꯝꯕꯗ꯭ꯔꯕꯥ ꯗꯦꯇꯥ ꯊꯥꯗꯣꯔꯛꯄꯥ ꯌꯥꯑꯣꯗꯅꯥ ꯈꯨꯗꯤꯡꯃꯛꯅꯥ ꯊꯕꯛ ꯍꯦꯟꯅꯥ ꯐꯪꯅꯕꯥ ꯃꯇꯦꯡ ꯄꯥꯡꯗꯨꯅꯥ ꯆꯥꯡ ꯅꯥꯏꯕꯥ, ꯌꯥꯝꯅꯥ ꯊꯨꯅꯥ ꯊꯣꯛꯄꯥ ꯑꯅꯨഭꯨꯇꯤ ꯑꯃꯥ ꯄꯤꯔꯤ꯫.