From 6b5938017b5105066d27484605af8dd88fab183d Mon Sep 17 00:00:00 2001
From: AstiaSun <anastasiia.bondarenko@ring.com>
Date: Mon, 28 Oct 2019 01:20:19 +0200
Subject: [mips/uk-ua] Add ukrainian translation for MIPS Assemly

---
 uk-ua/mips-ua.html.markdown | 366 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 366 insertions(+)
 create mode 100644 uk-ua/mips-ua.html.markdown

(limited to 'uk-ua/mips-ua.html.markdown')

diff --git a/uk-ua/mips-ua.html.markdown b/uk-ua/mips-ua.html.markdown
new file mode 100644
index 00000000..20fa7638
--- /dev/null
+++ b/uk-ua/mips-ua.html.markdown
@@ -0,0 +1,366 @@
+---
+language: "MIPS Assembly"
+filename: MIPS.asm
+contributors:
+  - ["Stanley Lim", "https://github.com/Spiderpig86"]
+translators:
+  - ["AstiaSun", "https://github.com/AstiaSun"]
+lang: uk-ua
+---
+
+Мова асемблера MIPS (англ. Microprocessor without Interlocked Pipeline Stages) була написана для роботи з мікропорцесорами MIPS, парадигма яких була описана в 1981 році [Джоном Геннессі](https://uk.wikipedia.org/wiki/Джон_Лерой_Геннессі). Ці RISC процесори використовуються у таких вбудованих системах, як маршрутизатори та мережеві шлюзи.
+
+[Read More](https://en.wikipedia.org/wiki/MIPS_architecture)
+
+```asm
+# Коментарі позначені як'#'
+
+# Всі символи після '#' ігноруються лексичним аналізатором асемблера.
+
+# Зазвичай програми поділяються на .data та .text частини
+
+.data # У цьому розділі дані зберігаються у пам'яті, виділеній в RAM, подібно до змінних
+	   # в мовах програмування вищого рівня
+
+  # Змінна оголошується наступним чином: [назва]: .[тип] [значенння] 
+  # Наприклад:
+  hello_world: .asciiz "Hello World\n"      # Оголосити текстову змінну
+  num1: .word 42                            # word - це чисельний тип 32-бітного розряду
+
+  arr1: .word 1, 2, 3, 4, 5                 # Масив чисел
+  arr2: .byte 'a', 'b'                      # Масив буквених символів (розмір кожного - 1 байт)
+  buffer: .space 60                         # Виділити місце в RAM 
+                                            # (не очищується, тобто не заповнюється 0)
+
+  # Розміри типів даних
+  _byte: .byte 'a'                          # 1 байт
+  _halfword: .half 53                       # 2 байти
+  _word: .word 3                            # 4 байти
+  _float: .float 3.14                       # 4 байти
+  _double: .double 7.0                      # 8 байтів
+
+  .align 2                                  # Вирівнення пам'яті даних, де число
+                                            # показує кількість байтів, вирівнених 
+                                            # у степені 2. (.align 2 означає 
+                                            # чисельне (word) вирівнювання оскільки 
+                                            # 2^2 = 4 байти)
+
+.text                                       # Розділ, що містить інструкції та
+                                            # логіку програми
+
+.globl _main                                # Оголошує назву інструкції як 
+                                            # глобальну, тобто, яка є доступною для
+                                            # всіх інших файлів
+
+  _main:                                    # програми MIPS виконують інструкції
+                                            # послідовно, тобто першочергово код
+                                            # буде виконуватись після цієї позначки
+
+    # Виведемо на екран "hello world"
+    la $a0, hello_world                     # Завантажує адресу тексту у пам'яті
+    li $v0, 4                               # Завантажує значення системної
+                                            # команди (вказуючи тип функціоналу)
+    syscall                                 # Виконує зазначену системну команду
+                                            # з обраним аргументом ($a0)
+
+    # Регісти (використовуються, щоб тримати дані протягом виконання програми)
+    # $t0 - $t9                             # Тимчасові регістри використовуються
+                                            # для проміжних обчислень всередині
+                                            # підпрограм (не зберігаються між 
+                                            # викликами функцій)
+
+    # $s0 - $s7                             # Збережені регісти, у яких значення 
+                                            # збегіраються між викликами підпрограм.
+                                            # Зазвичай збегрігаються у стеку.
+
+    # $a0 - $a3                             # Регістри для передачі аргументів для 
+                                            # підпрограм
+    # $v0 - $v1                             # Регістри для значень, що повертаються
+                                            # від викликаної функції
+
+    # Типи інструкції завантаження / збереження
+    la $t0, label                           # Скопіювати адресу в пам'яті, де 
+                                            # зберігається значення змінної label 
+                                            # в регістр $t0
+    lw $t0, label                           # Скопівати чисельне значення з пам'яті
+    lw $t1, 4($s0)                          # Скопівати чисельне значення з адреси
+                                            # пам'яті ресгіста зі зміщенням в 
+                                            # 4 байти (адреса + 4)
+    lb $t2, label                           # Скопіювати буквений символ в частину
+                                            # нижчого порядку регістра $t2
+    lb $t2, 0($s0)                          # Скопіювати буквений символ з адреси
+                                            # в $s0 із зсувом 0
+    # Подіне використання і 'lh' для halfwords
+
+    sw $t0, label                           # Збегігти чисельне значення в адресу в 
+                                            # пам'яті, що відповідає змінній label
+    sw $t0, 8($s0)                          # Збегігти чисельне значення в адресу, 
+                                            # зазначеній у $s0, та зі зсувом у 8 байтів
+    # Така ж ідея використання 'sb' та 'sh' для буквених символів та halfwords. 
+    # 'sa' не існує
+    
+    
+### Математичні операції ###
+  _math:
+    # Пам'ятаємо, що попередньо потрібно завантажити данні в пам'ять
+    lw $t0, num                             # Із розділа з данними
+    li $t0, 5                               # Або безпосередньо з константи
+    li $t1, 6
+    add $t2, $t0, $t1                       # $t2 = $t0 + $t1
+    sub $t2, $t0, $t1                       # $t2 = $t0 - $t1
+    mul $t2, $t0, $t1                       # $t2 = $t0 * $t1
+    div $t2, $t0, $t1                       # $t2 = $t0 / $t1 (Може не підтримуватись
+                                            # деякими версіями MARS)
+    div $t0, $t1                            # Виконує $t0 / $t1. Отримати частку можна
+                                            # за допомогою команди 'mflo', остаток - 'mfhi'
+
+    # Bitwise Shifting
+    sll $t0, $t0, 2                         # Побітовий здвиг вліво з безпосереднім
+                                            # значенням (константою) 2
+    sllv $t0, $t1, $t2                      # Здвиг вліво зі змінною кількістю у
+                                            # регістрі
+    srl $t0, $t0, 5                         # Побітовий здвиг вправо (не збегігає 
+                                            # знак, знак розширюється 0)
+    srlv $t0, $t1, $t2                      # Здвиг вправо зі змінною кількістю у
+                                            # регістрі
+    sra $t0, $t0, 7                         # Побітовий арифметичний збвиг вправо 
+                                            # (зберігає знак)
+    srav $t0, $t1, $t2                      # Здвиг вправо зі змінною кількістю у 
+                                            # регістрі
+
+    # Bitwise operators
+    and $t0, $t1, $t2                       # Побітове І (AND)
+    andi $t0, $t1, 0xFFF                    # Побітове І з беспосереднім значенням
+    or $t0, $t1, $t2                        # Побітове АЛЕ (OR)
+    ori $t0, $t1, 0xFFF                     # Побітове АЛЕ з беспосереднім значенням
+    xor $t0, $t1, $t2                       # Побітова виключна диз'юнкція (XOR)
+    xori $t0, $t1, 0xFFF                    # Побітове XOR з беспосереднім значенням
+    nor $t0, $t1, $t2                       # Побітова стрілка Пірса (NOR)
+
+## Розгалуження ##
+  _branching:
+    # В овсновному інструкції розгалуження мають наступну форму:
+    # <instr> <reg1> <reg2> <label>
+    # де label - це назва змінної, в яку ми хочемо перейти, якщо зазначене твердження
+    # правдиве
+
+    beq $t0, $t1, reg_eq                    # Перейдемо у розгалуження reg_eq
+                                            # якщо $t0 == $t1, інакше -
+                                            # винонати наступну строку
+    bne $t0, $t1, reg_neq                   # Розгалужується, якщо $t0 != $t1
+    b branch_target                         # Розгалуження без умови завжди виконується
+    beqz $t0, req_eq_zero                   # Розгалужується, якщо $t0 == 0
+    bnez $t0, req_neq_zero                  # Розгалужується, якщо $t0 != 0
+    bgt $t0, $t1, t0_gt_t1                  # Розгалужується, якщо $t0 > $t1
+    bge $t0, $t1, t0_gte_t1                 # Розгалужується, якщо $t0 >= $t1
+    bgtz $t0, t0_gt0                        # Розгалужується, якщо $t0 > 0
+    blt $t0, $t1, t0_gt_t1                  # Розгалужується, якщо $t0 < $t1
+    ble $t0, $t1, t0_gte_t1                 # Розгалужується, якщо $t0 <= $t1
+    bltz $t0, t0_lt0                        # Розгалужується, якщо $t0 < 0
+    slt $s0, $t0, $t1                       # Інструкція, що посилає сигнал коли
+                                            # $t0 < $t1, результат зберігається в $s0 
+                                            # (1 - правдиве твердження)
+
+    # Просте твердження якщо (if)
+    # if (i == j)
+    #     f = g + h;
+    #  f = f - i;
+
+    # Нехай $s0 = f, $s1 = g, $s2 = h, $s3 = i, $s4 = j
+    bne $s3, $s4, L1 # if (i !=j)
+    add $s0, $s1, $s2 # f = g + h
+
+    L1:
+      sub $s0, $s0, $s3 # f = f - i
+    
+    # Нижще наведений приклад знаходження максимального значееня з 3 чисел
+    # Пряма трансляція в Java з логіки MIPS:
+    # if (a > b)
+    #   if (a > c)
+    #     max = a;
+    #   else
+    #     max = c;
+    # else
+    #     max = b;
+    #   else
+    #     max = c;
+
+    # Нехай $s0 = a, $s1 = b, $s2 = c, $v0 = повернути регіст
+    ble $s0, $s1, a_LTE_b                   # якщо (a <= b) розгалуження(a_LTE_b)
+    ble $s0, $s2, max_C                     # якщо (a > b && a <=c) розгалуження(max_C)
+    move $v0, $s1                           # інакше [a > b && a > c] max = a
+    j done                                  # Перейти в кінець програми
+
+    a_LTE_b:                                # Мітка розгаруження, коли a <= b
+      ble $s1, $s2, max_C                   # якщо (a <= b && b <= c) розгалуження(max_C)
+      move $v0, $s1                         # якщо (a <= b && b > c) max = b
+      j done                                # Перейти в кінець програми
+
+    max_C:
+      move $v0, $s2                         # max = c
+
+    done:                                   # Кінець програми
+
+## Цикли ##
+  _loops:
+    # Цикл складається з умови виходу та з інстукції переходу після його завершення
+    li $t0, 0
+    while:
+      bgt $t0, 10, end_while                # Коли $t0 менше 10, продовжувати інтерації
+      addi $t0, $t0, 1                      # Збільшити значення
+      j while                               # Перейти на початок циклу
+    end_while:
+
+    # Транспонування 2D матриці
+    # Припустмо, що $a0 зберігає адресу цілочисельної матриці розмірністю 3 x 3
+    li $t0, 0                               # Лічильник для i
+    li $t1, 0                               # Лічильник для j
+    matrix_row:
+      bgt $t0, 3, matrix_row_end
+
+      matrix_col:
+        bgt $t1, 3, matrix_col_end
+
+        # ...
+
+        addi $t1, $t1, 1                  # Збільшити лічильник стовпця (col)
+      matrix_col_end:
+
+      # ...
+
+      addi $t0, $t0, 1
+    matrix_row_end:
+
+## Функції ##
+  _functions:
+    # Фукнції - це процедури, що викликаються, приймають аргументи та повертають значення
+
+    main:                                 # Програма починається з головної функції
+      jal return_1                        # jal збереже поточний PC в $ra,
+                                          # а потім перейде до return_1
+
+      # Як передати аргументи?
+      # По-перше, ми маємо передати значення аргументів у регістри аргументів
+      li $a0, 1
+      li $a1, 2
+      jal sum                             # Тепер ми можемо викликати функцію
+
+      # Як щодо рекурсії?
+      # Тут потрібно дещо більше роботи оскільки ми маємо впевнетись, що ми збережемо
+      # та зчитаємо попередній PC в $ra, оскільки jal автоматично перепише її при виклику
+      li $a0, 3
+      jal fact
+
+      li $v0, 10
+      syscall
+    
+    # Ця функйія повертає 1
+    return_1:
+      li $v0, 1                           # Завантажити val в регіст $v0
+      jr $ra                              # Повернутись до попереднього PC і продовжити виконання 
+
+
+    # Function with 2 args
+    sum:
+      add $v0, $a0, $a1
+      jr $ra                              # Повернутись
+
+    # Фекурсивна функція, яка знаходить факторіал
+    fact:
+      addi $sp, $sp, -8                   # Виділити місце в стеку
+      sw $s0, ($sp)                       # Зберегти регістр, що містить поточне число
+      sw $ra, 4($sp)                      # Зберегти попереднє PC
+
+      li $v0, 1                           # Проініціліазувати значення, що повертатиметься
+      beq $a0, 0, fact_done               # Закінчити, якщо параметр 0
+
+      # Інакше, продовжити рекурсію
+      move $s0, $a0                       # Скоріювати $a0 в $s0
+      sub $a0, $a0, 1
+      jal fact
+
+      mul $v0, $s0, $v0                   # Множення
+
+      fact_done:
+        lw $s0, ($sp)
+        lw $ra, ($sp)                     # Відновити PC
+        addi $sp, $sp, 8
+
+        jr $ra
+
+## Макроси ##
+  _macros:
+    # Макроси надзвичайно корисні для заміни блоків коду, що повторюються, за допомогою
+    # однієї змінної, для покращення читабельності
+    # Це не заміна функцій.
+    # Вони мають бути оголошені перед використанням
+
+    # Макрос для виведення нових строк (оскільки операція лосить часто виконується)
+    .macro println()
+      la $a0, newline                     # Значення нової строки зберігатиметься тут
+      li $v0, 4
+      syscall
+    .end_macro
+
+    println()                             # Асемблер скопіює цей блок коду сюди
+                                          # перед тим, як виконувати його
+
+    # Можна передавати параметри у макроси.
+    # Параметри позначаються знаком '%' з довільною назвою
+    .macro print_int(%num)
+      li $v0, 1
+      lw $a0, %num
+      syscall
+    .end_macro
+    
+    li $t0, 1
+    print_int($t0)
+    
+    # Ми таком можемо передавати безпосередньо значення в макроси
+    .macro immediates(%a, %b)
+      add $t0, %a, %b
+    .end_macro
+
+    immediates(3, 5)
+
+    # Одночасно із назвами змінних
+    .macro print(%string)
+      la $a0, %string
+      li $v0, 4
+      syscall
+    .end_macro
+
+    print(hello_world)
+
+## Масиви ##
+.data
+  list: .word 3, 0, 1, 2, 6                 # Це масив чисел
+  char_arr: .asciiz "hello"                 # Це текстовий масив
+  buffer: .space 128                        # Видтляє блок пам'яті, що
+                                            # автоматично не очищується
+                                            # Ці блоки пам'яті вирівнюють
+                                            # оддин одного
+
+.text
+  la $s0, list                              # Завантажити адрегу у список
+  li $t0, 0                                 # Лічильник
+  li $t1, 5                                 # Довжина списку
+
+  loop:
+    bgt $t0, $t1, end_loop
+
+    lw $a0, ($s0)
+    li $v0, 1
+    syscall                                 # Вивести число
+
+    addi $s0, $s0, 4                        # Розмір числа - 4 байти
+    addi $t0, $t0, 1                        # Збільшити
+    j loop
+  end_loop:
+
+## Включення ##
+# Це потрібно для імпорту стороннії файлівв програму (але насправді, код з цього файлу 
+# копіюється та вставляється в місце, де оголошений імпорт)
+.include "somefile.asm"
+
+```
-- 
cgit v1.2.3


From 210e9b50ee146eecd9bf9235790c7e8e1dfe6637 Mon Sep 17 00:00:00 2001
From: AstiaSun <anastasiia.bondarenko@ring.com>
Date: Fri, 1 Nov 2019 11:20:56 +0200
Subject: Fix discovered misspelling

---
 uk-ua/mips-ua.html.markdown | 122 ++++++++++++++++++++++----------------------
 1 file changed, 61 insertions(+), 61 deletions(-)

(limited to 'uk-ua/mips-ua.html.markdown')

diff --git a/uk-ua/mips-ua.html.markdown b/uk-ua/mips-ua.html.markdown
index 20fa7638..8d4517fe 100644
--- a/uk-ua/mips-ua.html.markdown
+++ b/uk-ua/mips-ua.html.markdown
@@ -8,9 +8,9 @@ translators:
 lang: uk-ua
 ---
 
-Мова асемблера MIPS (англ. Microprocessor without Interlocked Pipeline Stages) була написана для роботи з мікропорцесорами MIPS, парадигма яких була описана в 1981 році [Джоном Геннессі](https://uk.wikipedia.org/wiki/Джон_Лерой_Геннессі). Ці RISC процесори використовуються у таких вбудованих системах, як маршрутизатори та мережеві шлюзи.
+Мова ассемблера MIPS (англ. Microprocessor without Interlocked Pipeline Stages) була написана для роботи з мікропроцесорами MIPS, парадигма яких була описана в 1981 році [Джоном Геннессі](https://uk.wikipedia.org/wiki/Джон_Лерой_Геннессі). Ці RISC процесори використовуються у таких вбудованих системах, як маршрутизатори та мережеві шлюзи.
 
-[Read More](https://en.wikipedia.org/wiki/MIPS_architecture)
+[Детальніше](https://en.wikipedia.org/wiki/MIPS_architecture)
 
 ```asm
 # Коментарі позначені як'#'
@@ -22,7 +22,7 @@ lang: uk-ua
 .data # У цьому розділі дані зберігаються у пам'яті, виділеній в RAM, подібно до змінних
 	   # в мовах програмування вищого рівня
 
-  # Змінна оголошується наступним чином: [назва]: .[тип] [значенння] 
+  # Змінна оголошується наступним чином: [назва]: .[тип] [значення] 
   # Наприклад:
   hello_world: .asciiz "Hello World\n"      # Оголосити текстову змінну
   num1: .word 42                            # word - це чисельний тип 32-бітного розряду
@@ -39,7 +39,7 @@ lang: uk-ua
   _float: .float 3.14                       # 4 байти
   _double: .double 7.0                      # 8 байтів
 
-  .align 2                                  # Вирівнення пам'яті даних, де число
+  .align 2                                  # Вирівнювання пам'яті даних, де число
                                             # показує кількість байтів, вирівнених 
                                             # у степені 2. (.align 2 означає 
                                             # чисельне (word) вирівнювання оскільки 
@@ -63,15 +63,15 @@ lang: uk-ua
     syscall                                 # Виконує зазначену системну команду
                                             # з обраним аргументом ($a0)
 
-    # Регісти (використовуються, щоб тримати дані протягом виконання програми)
+    # Регістри (використовуються, щоб тримати дані протягом виконання програми)
     # $t0 - $t9                             # Тимчасові регістри використовуються
                                             # для проміжних обчислень всередині
                                             # підпрограм (не зберігаються між 
                                             # викликами функцій)
 
-    # $s0 - $s7                             # Збережені регісти, у яких значення 
-                                            # збегіраються між викликами підпрограм.
-                                            # Зазвичай збегрігаються у стеку.
+    # $s0 - $s7                             # Збережені регістри, у яких значення 
+                                            # зберігаються між викликами підпрограм.
+                                            # Зазвичай зберігаються у стеку.
 
     # $a0 - $a3                             # Регістри для передачі аргументів для 
                                             # підпрограм
@@ -82,28 +82,28 @@ lang: uk-ua
     la $t0, label                           # Скопіювати адресу в пам'яті, де 
                                             # зберігається значення змінної label 
                                             # в регістр $t0
-    lw $t0, label                           # Скопівати чисельне значення з пам'яті
-    lw $t1, 4($s0)                          # Скопівати чисельне значення з адреси
-                                            # пам'яті ресгіста зі зміщенням в 
+    lw $t0, label                           # Скопіювати чисельне значення з пам'яті
+    lw $t1, 4($s0)                          # Скопіювати чисельне значення з адреси
+                                            # пам'яті регістра зі зміщенням в 
                                             # 4 байти (адреса + 4)
     lb $t2, label                           # Скопіювати буквений символ в частину
                                             # нижчого порядку регістра $t2
     lb $t2, 0($s0)                          # Скопіювати буквений символ з адреси
                                             # в $s0 із зсувом 0
-    # Подіне використання і 'lh' для halfwords
+    # Подібне використання і 'lh' для halfwords
 
-    sw $t0, label                           # Збегігти чисельне значення в адресу в 
+    sw $t0, label                           # Зберегти чисельне значення в адресу в 
                                             # пам'яті, що відповідає змінній label
-    sw $t0, 8($s0)                          # Збегігти чисельне значення в адресу, 
-                                            # зазначеній у $s0, та зі зсувом у 8 байтів
+    sw $t0, 8($s0)                          # Зберегти чисельне значення в адресу, 
+                                            # що зазначена у $s0, та зі зсувом у 8 байтів
     # Така ж ідея використання 'sb' та 'sh' для буквених символів та halfwords. 
     # 'sa' не існує
     
     
 ### Математичні операції ###
   _math:
-    # Пам'ятаємо, що попередньо потрібно завантажити данні в пам'ять
-    lw $t0, num                             # Із розділа з данними
+    # Пам'ятаємо, що попередньо потрібно завантажити дані в пам'ять
+    lw $t0, num                             # Із розділа з даними
     li $t0, 5                               # Або безпосередньо з константи
     li $t1, 6
     add $t2, $t0, $t1                       # $t2 = $t0 + $t1
@@ -114,39 +114,39 @@ lang: uk-ua
     div $t0, $t1                            # Виконує $t0 / $t1. Отримати частку можна
                                             # за допомогою команди 'mflo', остаток - 'mfhi'
 
-    # Bitwise Shifting
-    sll $t0, $t0, 2                         # Побітовий здвиг вліво з безпосереднім
-                                            # значенням (константою) 2
-    sllv $t0, $t1, $t2                      # Здвиг вліво зі змінною кількістю у
+    # Бітовий зсув
+    sll $t0, $t0, 2                         # Побітовий зсув вліво на 2. Біти вищого порядку
+                                            # не зберігаються, нищого - заповнюються 0
+    sllv $t0, $t1, $t2                      # Зсув вліво зі змінною кількістю у
                                             # регістрі
-    srl $t0, $t0, 5                         # Побітовий здвиг вправо (не збегігає 
-                                            # знак, знак розширюється 0)
-    srlv $t0, $t1, $t2                      # Здвиг вправо зі змінною кількістю у
-                                            # регістрі
-    sra $t0, $t0, 7                         # Побітовий арифметичний збвиг вправо 
-                                            # (зберігає знак)
-    srav $t0, $t1, $t2                      # Здвиг вправо зі змінною кількістю у 
+    srl $t0, $t0, 5                         # Побітовий зсув вправо на 5 (не зберігає 
+                                            # біти, біти зліва заповнюються 0)
+    srlv $t0, $t1, $t2                      # Зсув вправо зі змінною кількістю у
                                             # регістрі
+    sra $t0, $t0, 7                         # Побітовий арифметичний зсув вправо 
+                                            # (зберігає біти)
+    srav $t0, $t1, $t2                      # Зсув вправо зі змінною кількістю у 
+                                            # регістрі зі збереження значеннь бітів
 
-    # Bitwise operators
+    # Побітові операції
     and $t0, $t1, $t2                       # Побітове І (AND)
-    andi $t0, $t1, 0xFFF                    # Побітове І з беспосереднім значенням
-    or $t0, $t1, $t2                        # Побітове АЛЕ (OR)
-    ori $t0, $t1, 0xFFF                     # Побітове АЛЕ з беспосереднім значенням
+    andi $t0, $t1, 0xFFF                    # Побітове І з безпосереднім значенням
+    or $t0, $t1, $t2                        # Побітове АБО (OR)
+    ori $t0, $t1, 0xFFF                     # Побітове АБО з безпосереднім значенням
     xor $t0, $t1, $t2                       # Побітова виключна диз'юнкція (XOR)
-    xori $t0, $t1, 0xFFF                    # Побітове XOR з беспосереднім значенням
+    xori $t0, $t1, 0xFFF                    # Побітове XOR з безпосереднім значенням
     nor $t0, $t1, $t2                       # Побітова стрілка Пірса (NOR)
 
 ## Розгалуження ##
   _branching:
-    # В овсновному інструкції розгалуження мають наступну форму:
+    # В основному інструкції розгалуження мають наступну форму:
     # <instr> <reg1> <reg2> <label>
     # де label - це назва змінної, в яку ми хочемо перейти, якщо зазначене твердження
     # правдиве
 
     beq $t0, $t1, reg_eq                    # Перейдемо у розгалуження reg_eq
                                             # якщо $t0 == $t1, інакше -
-                                            # винонати наступну строку
+                                            # виконати наступний рядок
     bne $t0, $t1, reg_neq                   # Розгалужується, якщо $t0 != $t1
     b branch_target                         # Розгалуження без умови завжди виконується
     beqz $t0, req_eq_zero                   # Розгалужується, якщо $t0 == 0
@@ -173,7 +173,7 @@ lang: uk-ua
     L1:
       sub $s0, $s0, $s3 # f = f - i
     
-    # Нижще наведений приклад знаходження максимального значееня з 3 чисел
+    # Нижче наведений приклад знаходження максимального значення з 3 чисел
     # Пряма трансляція в Java з логіки MIPS:
     # if (a > b)
     #   if (a > c)
@@ -185,13 +185,13 @@ lang: uk-ua
     #   else
     #     max = c;
 
-    # Нехай $s0 = a, $s1 = b, $s2 = c, $v0 = повернути регіст
+    # Нехай $s0 = a, $s1 = b, $s2 = c, $v0 = повернути регістр
     ble $s0, $s1, a_LTE_b                   # якщо (a <= b) розгалуження(a_LTE_b)
     ble $s0, $s2, max_C                     # якщо (a > b && a <=c) розгалуження(max_C)
     move $v0, $s1                           # інакше [a > b && a > c] max = a
     j done                                  # Перейти в кінець програми
 
-    a_LTE_b:                                # Мітка розгаруження, коли a <= b
+    a_LTE_b:                                # Мітка розгалуження, коли a <= b
       ble $s1, $s2, max_C                   # якщо (a <= b && b <= c) розгалуження(max_C)
       move $v0, $s1                         # якщо (a <= b && b > c) max = b
       j done                                # Перейти в кінець програми
@@ -203,16 +203,16 @@ lang: uk-ua
 
 ## Цикли ##
   _loops:
-    # Цикл складається з умови виходу та з інстукції переходу після його завершення
+    # Цикл складається з умови виходу та з інструкції переходу після його завершення
     li $t0, 0
     while:
-      bgt $t0, 10, end_while                # Коли $t0 менше 10, продовжувати інтерації
+      bgt $t0, 10, end_while                # Коли $t0 менше 10, продовжувати ітерації
       addi $t0, $t0, 1                      # Збільшити значення
       j while                               # Перейти на початок циклу
     end_while:
 
     # Транспонування 2D матриці
-    # Припустмо, що $a0 зберігає адресу цілочисельної матриці розмірністю 3 x 3
+    # Припустимо, що $a0 зберігає адресу цілочисельної матриці розмірністю 3 x 3
     li $t0, 0                               # Лічильник для i
     li $t1, 0                               # Лічильник для j
     matrix_row:
@@ -233,10 +233,10 @@ lang: uk-ua
 
 ## Функції ##
   _functions:
-    # Фукнції - це процедури, що викликаються, приймають аргументи та повертають значення
+    # Функції - це процедури, що викликаються, приймають аргументи та повертають значення
 
     main:                                 # Програма починається з головної функції
-      jal return_1                        # jal збереже поточний PC в $ra,
+      jal return_1                        # jal збереже поточний ПЦ (програмний центр) в $ra,
                                           # а потім перейде до return_1
 
       # Як передати аргументи?
@@ -246,36 +246,36 @@ lang: uk-ua
       jal sum                             # Тепер ми можемо викликати функцію
 
       # Як щодо рекурсії?
-      # Тут потрібно дещо більше роботи оскільки ми маємо впевнетись, що ми збережемо
-      # та зчитаємо попередній PC в $ra, оскільки jal автоматично перепише її при виклику
+      # Тут потрібно дещо більше роботи оскільки ми маємо впевнитись, що ми збережемо
+      # та зчитаємо попередній ПЦ в $ra, оскільки jal автоматично перепише її при виклику
       li $a0, 3
       jal fact
 
       li $v0, 10
       syscall
     
-    # Ця функйія повертає 1
+    # Ця функція повертає 1
     return_1:
       li $v0, 1                           # Завантажити val в регіст $v0
-      jr $ra                              # Повернутись до попереднього PC і продовжити виконання 
+      jr $ra                              # Повернутись до попереднього ПЦ і продовжити виконання 
 
 
-    # Function with 2 args
+    # Функція з двома аргументами
     sum:
       add $v0, $a0, $a1
       jr $ra                              # Повернутись
 
-    # Фекурсивна функція, яка знаходить факторіал
+    # Рекурсивна функція, яка знаходить факторіал
     fact:
       addi $sp, $sp, -8                   # Виділити місце в стеку
       sw $s0, ($sp)                       # Зберегти регістр, що містить поточне число
-      sw $ra, 4($sp)                      # Зберегти попереднє PC
+      sw $ra, 4($sp)                      # Зберегти попередній ПЦ
 
-      li $v0, 1                           # Проініціліазувати значення, що повертатиметься
+      li $v0, 1                           # Проініціалізувати значення, що повертатиметься
       beq $a0, 0, fact_done               # Закінчити, якщо параметр 0
 
       # Інакше, продовжити рекурсію
-      move $s0, $a0                       # Скоріювати $a0 в $s0
+      move $s0, $a0                       # Скопіювати $a0 в $s0
       sub $a0, $a0, 1
       jal fact
 
@@ -283,7 +283,7 @@ lang: uk-ua
 
       fact_done:
         lw $s0, ($sp)
-        lw $ra, ($sp)                     # Відновити PC
+        lw $ra, ($sp)                     # Відновити ПЦ
         addi $sp, $sp, 8
 
         jr $ra
@@ -295,9 +295,9 @@ lang: uk-ua
     # Це не заміна функцій.
     # Вони мають бути оголошені перед використанням
 
-    # Макрос для виведення нових строк (оскільки операція лосить часто виконується)
+    # Макрос для виведення нових рядків (оскільки операція досить часто виконується)
     .macro println()
-      la $a0, newline                     # Значення нової строки зберігатиметься тут
+      la $a0, newline                     # Значення нового рядка зберігатиметься тут
       li $v0, 4
       syscall
     .end_macro
@@ -316,7 +316,7 @@ lang: uk-ua
     li $t0, 1
     print_int($t0)
     
-    # Ми таком можемо передавати безпосередньо значення в макроси
+    # Значення також можна передавати безпосередньо в макроси
     .macro immediates(%a, %b)
       add $t0, %a, %b
     .end_macro
@@ -336,13 +336,13 @@ lang: uk-ua
 .data
   list: .word 3, 0, 1, 2, 6                 # Це масив чисел
   char_arr: .asciiz "hello"                 # Це текстовий масив
-  buffer: .space 128                        # Видтляє блок пам'яті, що
+  buffer: .space 128                        # Виділяє блок пам'яті, що
                                             # автоматично не очищується
-                                            # Ці блоки пам'яті вирівнюють
-                                            # оддин одного
+                                            # Ці блоки пам'яті вирівнені
+                                            # вирівнені поруч один з одним
 
 .text
-  la $s0, list                              # Завантажити адрегу у список
+  la $s0, list                              # Завантажити адресу списку
   li $t0, 0                                 # Лічильник
   li $t1, 5                                 # Довжина списку
 
@@ -359,7 +359,7 @@ lang: uk-ua
   end_loop:
 
 ## Включення ##
-# Це потрібно для імпорту стороннії файлівв програму (але насправді, код з цього файлу 
+# Потрібно для імпорту сторонніх файлів у програму (насправді, код з цього файлу 
 # копіюється та вставляється в місце, де оголошений імпорт)
 .include "somefile.asm"
 
-- 
cgit v1.2.3