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"