diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md
index d6ee8a88b..6cb286bf2 100644
--- a/1-js/02-first-steps/04-variables/article.md
+++ b/1-js/02-first-steps/04-variables/article.md
@@ -24,7 +24,11 @@ let message;
 let message;
 
 *!*
+<<<<<<< HEAD
 message = 'Привіт'; // збереження рядка 'Привіт' у змінній `message`
+=======
+message = 'Hello'; // store the string 'Hello' in the variable named message
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 */!*
 ```
 
diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index cd710cb7f..1bdb52937 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -106,10 +106,17 @@ for (let i = 0; i < 3; i++) { // показується 0, далі 1, поті
 
 | Назва частини  |          |                                                                            |
 |-------|----------|----------------------------------------------------------------------------|
+<<<<<<< HEAD
 | початок | `let i = 0`    | Виконується один раз, при вході в цикл.                                      |
 | умова | `i < 3`| Перевіряється перед кожною ітерацією циклу. Якщо умова невірна, цикл зупиняєтья.              |
 | тіло | `alert(i)`| Виконується знову і знову, поки умова є правдивою (`true`).                         |
 | крок| `i++`      | Виконується після тіла на кожній ітерації, але перед перевіркою умови. |
+=======
+| begin | `let i = 0`    | Executes once upon entering the loop.                                      |
+| condition | `i < 3`| Checked before every loop iteration. If false, the loop stops.              |
+| body | `alert(i)`| Runs again and again while the condition is truthy.                         |
+| step| `i++`      | Executes after the body on each iteration. |
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 Загальний алгоритм циклу працює так:
 
@@ -377,7 +384,11 @@ label: {
 }
 ```
 
+<<<<<<< HEAD
 ...Однак, 99.9% часу `break` використовується всередині циклів, як ми бачили в прикладах вище.  
+=======
+...Although, 99.9% of the time `break` is used inside loops, as we've seen in the examples above.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 Виклик `continue` можливий лише всередині циклу.
 ````
diff --git a/1-js/02-first-steps/15-function-basics/article.md b/1-js/02-first-steps/15-function-basics/article.md
index eb2badf74..c5be00eb0 100644
--- a/1-js/02-first-steps/15-function-basics/article.md
+++ b/1-js/02-first-steps/15-function-basics/article.md
@@ -181,7 +181,11 @@ alert( from ); // Анна
 
 Ми оголошуємо функції, вказуючи їхні параметри, потім викликаємо їх, передаючи аргументи.
 
+<<<<<<< HEAD
 Дехто може сказати, що в прикладі вище "функцію `showMessage` оголошено з двома параметрами, потім викликано з двома аргументами: `from` і `"Привіт"`".
+=======
+In the example above, one might say: "the function `showMessage` is declared with two parameters, then called with two arguments: `from` and `"Hello"`".
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 
 ## Типові значення
@@ -247,7 +251,11 @@ function showMessage(text) {
 showMessage(); // порожнє повідомлення
 ```
 
+<<<<<<< HEAD
 ...Або ми можемо використати оператор `||`:
+=======
+...Or we could use the `||` operator:
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 ```js
 function showMessage(text) {
diff --git a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md
index c1575b6eb..8b6d1d38a 100644
--- a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md
+++ b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md
@@ -4,7 +4,11 @@ importance: 2
 
 # Дві функції - один об’єкт
 
+<<<<<<< HEAD
 Чи можливо створити функції `A` та `B`, щоб `new A() == new B()`?
+=======
+Is it possible to create functions `A` and `B` so that `new A() == new B()`?
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 ```js no-beautify
 function A() { ... }
diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index a59604c7d..741a288f6 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -9,7 +9,11 @@ JavaScript не дозволяє налаштувати, як працюють 
 
 Це важливе обмеження, оскільки результат `obj1 + obj2` не може бути іншим об’єктом!
 
+<<<<<<< HEAD
 Наприклад, ми не можемо зробити об’єкти, що представляють вектори або матриці (або досягнення або що завгодно) та додати їх і очікувати, що "підсумковий" результат буде об’єктом. Автоматично такі архітектурні особливості недоступні.
+=======
+E.g. we can't make objects representing vectors or matrices (or achievements or whatever), add them and expect a "summed" object as the result. Such architectural feats are automatically "off the board".
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 Отже, оскільки ми не можемо автоматично за допомогою мови програмування виконувати подібні операції над об’єктами, то в реальних проєктах немає "математики з об’єктами". Коли стаються подібні операції (наприклад, `obj1 + obj2`), причиною цьому зазвичай є помилка програмування.
 
@@ -133,8 +137,13 @@ alert(user + 500); // hint: default -> 1500
 
 Якщо немає `Symbol.toPrimitive` тоді JavaScript намагається знайти методи `toString` і `valueOf`:
 
+<<<<<<< HEAD
 - Для "string" підказки: `toString`, і якщо цей метод не існує, то `valueOf` (таким чином `toString` має пріоритет при перетворенні в рядок).
 - Для інших підказок: `valueOf`, і якщо це не існує, то `toString` (таким чином `valueOf` має пріоритет для математики).
+=======
+- For the "string" hint: `toString`, and if it doesn't exist, then `valueOf` (so `toString` has the priority for string conversions).
+- For other hints: `valueOf`, and if it doesn't exist, then `toString` (so `valueOf` has the priority for maths).
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 Методи `toString` і `valueOf` походять з давніх часів. Вони не є символами (багато часу назад символи не існували), а скоріше є "звичними" методами, що названі за допомогою рядків. Вони забезпечують альтернативний шлях "старого стилю" для реалізації перетворення.
 
@@ -274,4 +283,8 @@ alert(obj + 2); // 22 ("2" + 2), перетворення до примітив
 
 На практиці досить часто для реалізації достатньо лише `obj.toString()` як методу для перетворення рядків, який повинен повернути "читабельне для людини" представлення об’єкта, для цілей логування або пошуку помилок.
 
+<<<<<<< HEAD
 Що стосується математичних операцій, JavaScript не надає способу "перевизначити" їх через методи, тому реальні проєкти рідко використовують математичні операції на об’єктах.
+=======
+As for math operations, JavaScript doesn't provide a way to "override" them using methods, so real life projects rarely use them on objects.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
diff --git a/1-js/05-data-types/02-number/article.md b/1-js/05-data-types/02-number/article.md
index a868d6f8d..aea299cc5 100644
--- a/1-js/05-data-types/02-number/article.md
+++ b/1-js/05-data-types/02-number/article.md
@@ -4,7 +4,11 @@
 
 1. Звичайні числа в JavaScript, що зберігаються у 64-бітному форматі [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754-2008_revision), також відомі як "подвійні точні числа з плаваючою комою". Це числа, які ми використовуємо більшість часу, і про них ми поговоримо в цьому розділі.
 
+<<<<<<< HEAD
 2. Числа BigInt, для відображення цілих чисел довільної довжини. Іноді вони потрібні, оскільки звичайне число не може безпечно перевищувати <code>2<sup>53</sup></code> або бути менше <code>-2<sup>53</sup></code>. Оскільки числа BigInt використовуються в декількох спеціальних областях, їм присвячено окремий розділ <info:bigint>.
+=======
+2. BigInt numbers, to represent integers of arbitrary length. They are sometimes needed, because a regular number can't safely exceed <code>2<sup>53</sup></code> or be less than <code>-2<sup>53</sup></code>. As bigints are used in few special areas, we devote them a special chapter <info:bigint>.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 Тож тут ми поговоримо про звичайні числа. Поглибимо наші знання про них.
 
@@ -37,8 +41,13 @@ alert( 7.3e9 );  // 7.3 мільярдів (таке ж саме що 7300000000
 Іншими словами, `"e"` помножує число на `1` із заданим числом нулів.
 
 ```js
+<<<<<<< HEAD
 1e3 === 1 * 1000; // e3 означає *1000
 1.23e6 === 1.23 * 1000000; // e6 означає *1000000
+=======
+1e3 === 1 * 1000; // e3 means *1000
+1.23e6 === 1.23 * 1000000; // e6 means *1000000
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 ```
 
 Тепер напишемо щось дуже маленьке. Наприклад, 1 мікросекунда (одна мільйонна частина секунди):
@@ -53,15 +62,26 @@ let ms = 0.000001;
 let ms = 1e-6; // шість нулів зліва від 1
 ```
 
+<<<<<<< HEAD
 Якщо порахувати нулі в `0.000001`, їх буде 6. Так що, цілком очікувано, що це `1e-6`.
+=======
+If we count the zeroes in `0.000001`, there are 6 of them. So naturally it's `1e-6`.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 Іншими словами, від’ємне число після `"е"` означає ділення на 1 з заданою кількістю нулів:
 
 ```js
+<<<<<<< HEAD
 // -3 ділиться на 1 з 3 нулями
 1e-3 === 1 / 1000; // 0.001
 
 // -6 ділиться на 1 з 6 нулями
+=======
+// -3 divides by 1 with 3 zeroes
+1e-3 === 1 / 1000; // 0.001
+
+// -6 divides by 1 with 6 zeroes
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 1.23e-6 === 1.23 / 1000000; // 0.00000123
 ```
 
@@ -119,6 +139,11 @@ alert( num.toString(2) );   // 11111111
 
 Також можна написати `(123456).toString(36)`.
 
+<<<<<<< HEAD
+=======
+Also could write `(123456).toString(36)`.
+
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 ```
 
 ## Округлення
@@ -329,7 +354,11 @@ let num = +prompt("Enter a number", '');
 alert( isFinite(num) );
 ```
 
+<<<<<<< HEAD
 Зауважте, що порожній рядок, або рядок з пробілів трактується як `0` у всіх числових функціях, включаючи `isFinite`.
+=======
+Please note that an empty or a space-only string is treated as `0` in all numeric functions including `isFinite`.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 ```smart header="Порівняння з `Object.is`"
 
diff --git a/1-js/05-data-types/09-keys-values-entries/article.md b/1-js/05-data-types/09-keys-values-entries/article.md
index 2e0bab1b0..9e9d148d5 100644
--- a/1-js/05-data-types/09-keys-values-entries/article.md
+++ b/1-js/05-data-types/09-keys-values-entries/article.md
@@ -76,9 +76,15 @@ for (let value of Object.values(user)) {
 
 Якщо б ми хотіли їх застосувати, тоді б ми використовували `Object.entries` з подальшим викликом `Object.fromEntries`:
 
+<<<<<<< HEAD
 1. Викликаємо `Object.entries(obj)`, щоб отримати масив пар ключ/значення з `obj`.
 2. На ньому використовуємо методи масиву, наприклад `map`, щоб перетворити ці пари ключів/значень.
 3. Використаємо `Object.fromEntries(array)` на отриманому масиві, щоб перетворити його знову на об’єкт.
+=======
+1. Use `Object.entries(obj)` to get an array of key/value pairs from `obj`.
+2. Use array methods on that array, e.g. `map`, to transform these key/value pairs.
+3. Use `Object.fromEntries(array)` on the resulting array to turn it back into an object.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 Наприклад, у нас є об’єкт з цінами, і ми б хотіли їх подвоїти:
 
@@ -91,8 +97,13 @@ let prices = {
 
 *!*
 let doublePrices = Object.fromEntries(
+<<<<<<< HEAD
   // перетворити ціни на масив, потім застосувати map, щоб перетворити на пари ключ/значення
   // а потім fromEntries повертає об’єкт
+=======
+  // convert prices to array, map each key/value pair into another pair
+  // and then fromEntries gives back the object
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
   Object.entries(prices).map(entry => [entry[0], entry[1] * 2])
 );
 */!*
@@ -100,4 +111,8 @@ let doublePrices = Object.fromEntries(
 alert(doublePrices.meat); // 8
 ```
 
+<<<<<<< HEAD
 З першого погляду це може здатися важким, але стане зрозумілим після того, як ви використаєте це декілька разів. Таким чином ми можемо створювати потужні ланцюги перетворень.
+=======
+It may look difficult at first sight, but becomes easy to understand after you use it once or twice. We can make powerful chains of transforms this way.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index a27994b87..ba7699943 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -4,7 +4,11 @@
 ```smart header="Ця стаття призначена для розуміння старих скриптів"
 Інформація в цій статті корисна для розуміння старих скриптів.
 
+<<<<<<< HEAD
 Зараз так код не пишуть.
+=======
+That's not how we write new code.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 ```
 
 У першому розділі про [змінні](info:variables), ми ознайомились з трьома способами оголошення змінних: