diff --git a/1-js/01-getting-started/1-intro/article.md b/1-js/01-getting-started/1-intro/article.md
index 6c5e05c10..80c9fe5a9 100644
--- a/1-js/01-getting-started/1-intro/article.md
+++ b/1-js/01-getting-started/1-intro/article.md
@@ -46,8 +46,12 @@ Il motore applica ottimizzazioni ad ogni passo del processo. Anche durate l'esec
 
 Il JavaScript ad giorno d'oggi è un linguaggio di programmazione "sicuro". Non consente alcun accesso a basso livello alla memoria o alla CPU, questo perchè è stato creato con lo scopo di funzionare nei browser, che non richiedono questo tipo di privilegi.
 
+<<<<<<< HEAD
 Le possibilità dipendono molto dall'ambiente in cui si esegue JavaScript. Ad esempio, 
  [Node.JS](https://wikipedia.org/wiki/Node.js) supporta funzioni che consentono a JavaScript di scrivere/leggere file, eseguire richieste web, etc.
+=======
+JavaScript's capabilities greatly depend on the environment it's running in. For instance, [Node.js](https://wikipedia.org/wiki/Node.js) supports functions that allow JavaScript to read/write arbitrary files, perform network requests, etc.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 JavaScript integrato nel browser può fare qualsiasi cosa legata alla manipolazione della pagina, interagire con l'utente e con il server.
 
@@ -90,6 +94,10 @@ Ci sono almeno *tre* cose che rendono grande JavaScript:
 + Operazioni seSupporatomplici vengono eseguite semplicemente.
 + Supportato dai maggiori browser ed è attivo di default.
 ```
+<<<<<<< HEAD
+=======
+JavaScript is the only browser technology that combines these three things.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Queste tre caratteristiche combinate esistono solo in JavaScript e in nessun'altra tecnologia web.
 
diff --git a/1-js/01-getting-started/1-intro/limitations.png b/1-js/01-getting-started/1-intro/limitations.png
index 4063bbcf2..3ef6b1e08 100644
Binary files a/1-js/01-getting-started/1-intro/limitations.png and b/1-js/01-getting-started/1-intro/limitations.png differ
diff --git a/1-js/01-getting-started/1-intro/limitations@2x.png b/1-js/01-getting-started/1-intro/limitations@2x.png
index 55c030ef3..7aa1c41ae 100644
Binary files a/1-js/01-getting-started/1-intro/limitations@2x.png and b/1-js/01-getting-started/1-intro/limitations@2x.png differ
diff --git a/1-js/01-getting-started/2-code-editors/article.md b/1-js/01-getting-started/2-code-editors/article.md
index 37974ffc1..e9e1f098c 100644
--- a/1-js/01-getting-started/2-code-editors/article.md
+++ b/1-js/01-getting-started/2-code-editors/article.md
@@ -2,6 +2,7 @@
 
 Un code editor è il posto in cui i programmatori spendo la maggior parte del loro tempo.
 
+<<<<<<< HEAD
 Ce ne sono due esemplari: IDE ed editor semplici. Molte persone si trovano bene a scegliere uno strumento per ognuno dei due tipi.
 
 ## IDE
@@ -19,6 +20,24 @@ Se non hai ancora considerato di scegliere un IDE, dai un occhiata a queste alte
 Tutti gli IDE sono multi-piattaforma.
 
 Per Windows, c'e anche l'editor "Visual Studio", da non confondere con "Visual Studio Code". "Visual Studio" è a pagamento ed è un potente editor disponibile solo per Windows, ottimo per piattaforme .NET. E' disponibile una versione gratuita ([Visual Studio Community](https://www.visualstudio.com/vs/community/).
+=======
+There are two main types of code editors: IDEs and lightweight editors. Many people use one tool of each type.
+
+## IDE
+
+The term [IDE](https://en.wikipedia.org/wiki/Integrated_development_environment) (Integrated Development Environment) refers to a powerful editor with many features that usually operates on a "whole project." As the name suggests, it's not just an editor, but a full-scale "development environment."
+
+An IDE loads the project (which can be many files), allows navigation between files, provides autocompletion based on the whole project (not just the open file), and integrates with a version management system (like [git](https://git-scm.com/)), a testing environment, and other "project-level" stuff.
+
+If you haven't selected an IDE yet, consider the following options:
+
+- [WebStorm](http://www.jetbrains.com/webstorm/) for frontend development. The same company offers other editors for other languages (paid).
+- [Netbeans](http://netbeans.org/) (free).
+
+All of these IDEs are cross-platform.
+
+For Windows, there's also "Visual Studio", not to be confused with "Visual Studio Code." "Visual Studio" is a paid and mighty Windows-only editor, well-suited for the .NET platform. A free version of it is called [Visual Studio Community](https://www.visualstudio.com/vs/community/).
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Molti IDE sono a pagamento ma offrono un periodo di prova gratuito. Solitamente il loro costo è trascurabile se paragonato allo stipendio di una sviluppatore qualificato, è quindi importante scegliere il migliore in base alle proprie esigenze.
 
@@ -34,11 +53,19 @@ Nella pratica, gli editor semplici possono avere molti plugin tra cui sintassi a
 
 Meritano attenzione le seguenti opzioni:
 
+<<<<<<< HEAD
 - [Visual Studio Code](https://code.visualstudio.com/) (multi-piattaforma, gratuito).
 - [Atom](https://atom.io/) (multi-piattaforma, gratuito).
 - [Sublime Text](http://www.sublimetext.com) (multi-piattaforma, shareware).
 - [Notepad++](https://notepad-plus-plus.org/) (Windows, gratuito).
 - [Vim](http://www.vim.org/) e [Emacs](https://www.gnu.org/software/emacs/) sono particolarmente carini se si sanno utilizzare.
+=======
+- [Visual Studio Code](https://code.visualstudio.com/) (cross-platform, free) also has many IDE-like features.
+- [Atom](https://atom.io/) (cross-platform, free).
+- [Sublime Text](http://www.sublimetext.com) (cross-platform, shareware).
+- [Notepad++](https://notepad-plus-plus.org/) (Windows, free).
+- [Vim](http://www.vim.org/) and [Emacs](https://www.gnu.org/software/emacs/) are also cool if you know how to use them.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## I miei preferiti
 
@@ -46,8 +73,13 @@ La personale preferenza dell'autore è di avere entrambi, un IDE per il progetto
 
 Io personalmente utilizzo:
 
+<<<<<<< HEAD
 - [WebStorm](http://www.jetbrains.com/webstorm/) per JS, anche se ci sono più linguaggi in un progetto posso intercambiarli tramite JetBrains.
 - Come editor semplice -- [Sublime Text](http://www.sublimetext.com) o [Atom](https://atom.io/).
+=======
+- As an IDE for JS -- [WebStorm](http://www.jetbrains.com/webstorm/) (I switch to one of the other JetBrains offerings when using other languages)
+- As a lightweight editor -- [Sublime Text](http://www.sublimetext.com) or [Atom](https://atom.io/).
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Non intestarditevi
 
@@ -55,4 +87,8 @@ Gli editor elencanti sopra sono sono quelli che io e i miei amici, che considero
 
 Ci sono altri grandi edito nel nostro grande mondo. Scegli quindi quello che più ti si addice.
 
+<<<<<<< HEAD
 La scelta di un edito, come degli altri strumenti, è individuale e dipende dai progetti, abitudini e preferenze personali.
+=======
+The choice of an editor, like any other tool, is individual and depends on your projects, habits, and personal preferences.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/01-getting-started/3-devtools/article.md b/1-js/01-getting-started/3-devtools/article.md
index 572851ff1..e369aa746 100644
--- a/1-js/01-getting-started/3-devtools/article.md
+++ b/1-js/01-getting-started/3-devtools/article.md
@@ -1,15 +1,27 @@
 # Developer console
 
+<<<<<<< HEAD
 Il codice è incline a contenere errori. E' molto probabile che tu commetta errori... Di cosa sto parlando? *Sicuramente* commetterai errori, sempre che tu sia umano, e non un [robot](https://en.wikipedia.org/wiki/Bender_(Futurama)).
 
 In un browser però, l'utente non può vedere gli errori. Quindi se qualcosa non funziona nello script, noi non possiamo vedere cosa non va e non possiamo perciò sistemarlo.
+=======
+Code is prone to errors. You will quite likely make errors... Oh, what am I talking about? You are *absolutely* going to make errors, at least if you're a human, not a [robot](https://en.wikipedia.org/wiki/Bender_(Futurama)).
+
+But in the browser, users don't see errors by default. So, if something goes wrong in the script, we won't see what's broken and can't fix it.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Per poter visualizzare gli errori e ricevere altre informazioni utili riguardo gli script, i browser integrano degli "strumenti di sviluppo".
 
+<<<<<<< HEAD
 Molto spesso gli sviluppatori tendono ad utilizzare Chrome o Firefox poichè questi browser forniscono i migliori strumenti per lo sviluppo. Anche gli altri browser contengono gli strumenti per lo sviluppo, talvolta con caratteristiche speciali, ma più che altro giocano a "prendere" Chrome e Firefox.
 Quindi molte perone hanno un browser "preferito" e utilizzano gli altri solo quando un problema è specifico di quel browser.
 
 Gli strumenti di sviluppo sono potenti; hanno molte caratteristiche. Prima di tutto, dobbiamo capire come ottenerli, come cercare errori e come eseguire comandi JavaScript.
+=======
+Most developers lean towards Chrome or Firefox for development because those browsers have the best developer tools. Other browsers also provide developer tools, sometimes with special features, but are usually playing "catch-up" to Chrome or Firefox. So most developers have a "favorite" browser and switch to others if a problem is browser-specific.
+
+Developer tools are potent; they have many features. To start, we'll learn how to open them, look at errors, and run JavaScript commands.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Google Chrome
 
@@ -32,28 +44,53 @@ Il look esatto degli strumenti di sviluppo dipenderà dalla tua versione di Chro
 
 Sotto il messaggio d'errore, c'e un simbolo blu `>`. Questo indica la "riga di comando" dove noi possiamo digitare dei comandi JavaScript. Premendo `key:Enter` si eseguono (`key:Shift+Enter` per inserire comandi multi-linea).
 
+<<<<<<< HEAD
 Adesso possiamo visualizzare gli errori, ed è già abbastanza come inizio. Ritorneremo sugli strumenti di sviluppo più avanti e analizzeremo il debugging più in profondità nel capitolo <info:debugging-chrome>.
+=======
+Now we can see errors, and that's enough for a start. We'll come back to developer tools later and cover debugging more in-depth in the chapter <info:debugging-chrome>.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 
 ## Firefox, Edge, and others
 
 Molti altri browser utilizzano `key:F12` per aprire gli strumenti di sviluppo.
 
+<<<<<<< HEAD
 Lo stile è comunque molto simile. Quando avrai imparato come utilizzare uno di questi strumenti (puoi iniziare con quelli di Chrome), potrai facilmente passare agli altri.
+=======
+The look & feel of them is quite similar. Once you know how to use one of these tools (you can start with Chrome), you can easily switch to another.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Safari
 
 Safari (Mac browser, non supportato da Windows/Linux) è un pò speciale in questo ambito. E' necessario attivare prima il "Menu di Sviluppo".
 
+<<<<<<< HEAD
 Apri le Impostazioni e vai sul pannello "Avanzate". In basso troverai un'opzione da spuntare:
+=======
+Open Preferences and go to the "Advanced" pane. There's a checkbox at the bottom:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ![safari](safari.png)
 
 Adesso tramite `key:Cmd+Opt+C` puoi attivare/disattivare la console. Inoltre noterai che un nuovo menu "Sviluppo" è apparso. Contiene molti comandi e opzioni.
 
+<<<<<<< HEAD
 ## Riepilogo
 
 - Gli strumenti di sviluppo ci consentono di trovare gli errori, eseguire comandi, esaminare variabili e molto altro.
 - Possono essere aperti con `key:F12` per la maggior parte dei browser in Windows. Chrome su Mac `key:Cmd+Opt+J`, Safari: `key:Cmd+Opt+C` (avendolo precedentemente abilitato).
+=======
+## Multi-line input
+
+Usually, when we put a line of code into the console, and then press `key:Enter`, it executes.
+
+To insert multiple lines, press `key:Shift+Enter`.
+
+## Summary
+
+- Developer tools allow us to see errors, run commands, examine variables, and much more.
+- They can be opened with `key:F12` for most browsers on Windows. Chrome for Mac needs `key:Cmd+Opt+J`, Safari: `key:Cmd+Opt+C` (need to enable first).
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Adesso abbiamo l'ambiente di sviluppo pronto. Nella prossima sezione inizieremo ad analizzare JavaScript.
diff --git a/1-js/02-first-steps/01-hello-world/article.md b/1-js/02-first-steps/01-hello-world/article.md
index 868a71c9c..20c53e995 100644
--- a/1-js/02-first-steps/01-hello-world/article.md
+++ b/1-js/02-first-steps/01-hello-world/article.md
@@ -1,16 +1,30 @@
 # Hello, world!
 
+<<<<<<< HEAD
 Il seguente tutorial tratta del core(nucleo) JavaScript, che è indipendente dalla piattaforma. Inoltre, più avanti, imparerai Node.JS e altre piattaforme che ne fanno utilizzo.
 
 Abbiamo bisogno di un ambiente di lavoro per eseguire i nostri script, e il fatto che questo libro sia online, rende il browser un ottima scelta. Cercheremo di mantenere al minimo l'utilizzo dei comandi specifici per browser (come `alert`), cosi non dovrai perdere la testa se deciderai di spostarti in altri ambienti come Node.JS. In ogni caso, i dettagli browser vengono spiegati in dettaglio nella [prossima parte](/ui) del tutorial.
 
 Quindi prima di tutto, vediamo come inserire uno script in una pagina web. Per ambienti server-side, è sufficiente eseguirli con un comando come `"node my.js"` in Node.JS.
+=======
+The tutorial that you're reading is about core JavaScript, which is platform-independent. Later on, you'll learn about Node.js and other platforms that use it.
+
+But we need a working environment to run our scripts and, since this book is online, the browser is a good choice. We'll keep the amount of browser-specific commands (like `alert`) to a minimum so that you don't spend time on them if you plan to concentrate on another environment (like Node.js). We'll focus on JavaScript in the browser in the [next part](/ui) of the tutorial.
+
+So first, let's see how we attach a script to a webpage. For server-side environments (like Node.js), you can execute the script with a command like `"node my.js"`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Il tag "script"
 
 I programmi JavaScript possono essere inseriti in qualunque parte di un documento HTML, con l'utilizzo del tag `<script>`.
 
+<<<<<<< HEAD
 Ad esempio:
+=======
+JavaScript programs can be inserted into any part of an HTML document with the help of the `<script>` tag.
+
+For instance:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```html run height=100
 <!DOCTYPE HTML>
@@ -34,6 +48,7 @@ Ad esempio:
 ```
 
 ```online
+<<<<<<< HEAD
 Puoi eseguire l'esempio cliccando su "Play" tramite il bottone in altro a destra.
 ```
 
@@ -52,6 +67,26 @@ Il tag `<script>` ha un paio di attributi che vengono utilizzati raramente, ma 
 
 Commenti prima e dopo lo script.
 : Nei più vecchi libri, è possibile trovare un commento all'interno dell'elemento `<script>`, come segue:
+=======
+You can run the example by clicking the "Play" button in the right-top corner of the box above.
+```
+
+The `<script>` tag contains JavaScript code which is automatically executed when the browser processes the tag.
+
+
+## Modern markup
+
+The `<script>` tag has a few attributes that are rarely used nowadays but can still be found in old code:
+
+The `type` attribute: <code>&lt;script <u>type</u>=...&gt;</code>
+: The old HTML standard, HTML4, required a script to have a `type`. Usually it was `type="text/javascript"`. It's not required anymore. Also, the modern HTML standard, HTML5, totally changed the meaning of this attribute. Now, it can be used for JavaScript modules. But that's an advanced topic; we'll talk about modules in another part of the tutorial. 
+
+The `language` attribute: <code>&lt;script <u>language</u>=...&gt;</code>
+: This attribute was meant to show the language of the script. This attribute no longer makes sense because JavaScript is the default language. There is no need to use it.
+
+Comments before and after scripts.
+: In really ancient books and guides, you may find comments inside `<script>` tags, like this:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
     ```html no-beautify
     <script type="text/javascript"><!--
@@ -59,21 +94,37 @@ Commenti prima e dopo lo script.
     //--></script>
     ```
 
+<<<<<<< HEAD
     Questo trucco non viene più utilizzato nel moderno JavaScript. I commenti venivano utilizzati per nascondere il codice JavaScript dai vecchi browser che non conoscevano il tag `<script>`.I browser rilasciati negli utlimi 15 anni non hanno questo problema, questo tipo di strategia può aiutarti a riconsocere i vecchi codici.
+=======
+    This trick isn't used in modern JavaScript. These comments hid JavaScript code from old browsers that didn't know how to process the `<script>` tag. Since browsers released in the last 15 years don't have this issue, this kind of comment can help you identify really old code.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Script esterni
 
 Se abbiamo molto codice JavaScript, possiamo inserirlo in un file separato.
 
+<<<<<<< HEAD
 Il file dello script viene integrato nel codice HTML tramtie l'attributo `src`:
+=======
+If we have a lot of JavaScript code, we can put it into a separate file.
+
+Script files are attached to HTML with the `src` attribute:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```html
 <script src="/https/patch-diff.githubusercontent.com/path/to/script.js"></script>
 ```
 
+<<<<<<< HEAD
 Questo `/path/to/script.js` è il percorso assoluto al file che contiene lo script (dalla root del sito).
 
 E' anche possibile fornire un percorso relativo a partire dalla pagina corrente. Per esempio `src="script.js"` significa che il file `"script.js"` si trova nella cartella corrente.
+=======
+Here, `/path/to/script.js` is an absolute path to the script file (from the site root).
+
+You can also provide a relative path from the current page. For instance, `src="script.js"` would mean a file `"script.js"` in the current folder.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Possiamo anche fornire un URL. Per esempio:
 
@@ -92,6 +143,7 @@ Per integrare più script, utilzzate più volte il tag:
 ```smart
 Come regola da seguire, solo gli script molto semplici vanno inseriti all'interno dell'HTML. Quelli più complessi vanno inseriti in file separati.
 
+<<<<<<< HEAD
 Il beneficio di inserire gli script in file separati è che il browser andrà a scaricarli e li memorizzerà nella sua [cache](https://en.wikipedia.org/wiki/Web_cache).
 
 Cosi facendo, le altre pagine che vorranno utilizzare lo stesso script lo preleveranno dallacache invece che riscaricarlo. Quindi il file verrà scaricato una sola volta.
@@ -101,6 +153,17 @@ Questo risparmierà traffico e renderà le pagine più veloci.
 
 ````warn header="Se `src` è impostato, il contenuto all'interno di script verrà ignorato."
 Quindi un tag `<script>` non può avere sia `src` che codice incorporato.
+=======
+The benefit of a separate file is that the browser will download it and store it in its [cache](https://en.wikipedia.org/wiki/Web_cache).
+
+Other pages that reference the same script will take it from the cache instead of downloading it, so the file is actually downloaded only once.
+
+That reduces traffic and makes pages faster.
+```
+
+````warn header="If `src` is set, the script content is ignored."
+A single `<script>` tag can't have both the `src` attribute and code inside.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Questo non funziona:
 
@@ -110,7 +173,11 @@ Questo non funziona:
 </script>
 ```
 
+<<<<<<< HEAD
 Dobbiamo scegliere: o esterno `<script src="…">` o il semplice tag `<script>` con all'interno il codice.
+=======
+We must choose either an external `<script src="…">` or a regular `<script>` with code.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 L'esempio precedete può essere diviso in due script:
 
@@ -121,10 +188,20 @@ L'esempio precedete può essere diviso in due script:
 </script>
 ```
 
+<<<<<<< HEAD
 ## Riepilogo
+=======
+- We can use a `<script>` tag to add JavaScript code to a page.
+- The `type` and `language` attributes are not required.
+- A script in an external file can be inserted with `<script src="path/to/script.js"></script>`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 - Possiamo usare il tag `<script>` per aggiungere codice JavaScript alla pagina.
 - Gli attributi `type` e `language` non sono richiesti.
 - Uno script in un file esterno può essere inserito con `<script src="path/to/script.js"></script>`.
 
+<<<<<<< HEAD
 C'e ancora molto da imparare riguaro gli script browser e la loro interazione con le pagine web. Ma tenete a mente che questa parte del tutorial è dedicata al linguaggio JavaScript, quindi non dobbiamo distrarci da questo obbiettivo. Andremo ad utilizzare il browser come piattaforma in cui eseguire JavaScript, che è molto utile, ma è solo uno dei tanti modi. 
+=======
+There is much more to learn about browser scripts and their interaction with the webpage. But let's keep in mind that this part of the tutorial is devoted to the JavaScript language, so we shouldn't distract ourselves with browser-specific implementations of it. We'll be using the browser as a way to run JavaScript, which is very convenient for online reading, but only one of many.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/02-first-steps/01-hello-world/hello-world-render.png b/1-js/02-first-steps/01-hello-world/hello-world-render.png
index ffe810697..ba94e017d 100644
Binary files a/1-js/02-first-steps/01-hello-world/hello-world-render.png and b/1-js/02-first-steps/01-hello-world/hello-world-render.png differ
diff --git a/1-js/02-first-steps/01-hello-world/hello-world-render@2x.png b/1-js/02-first-steps/01-hello-world/hello-world-render@2x.png
index c4411027c..9b2d4479f 100644
Binary files a/1-js/02-first-steps/01-hello-world/hello-world-render@2x.png and b/1-js/02-first-steps/01-hello-world/hello-world-render@2x.png differ
diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index 8ee513608..73a5a6542 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -1,21 +1,38 @@
 # Struttura del codice
 
+<<<<<<< HEAD
 La prima cosa da studiare riguarda il come è strutturato il codice.
+=======
+The first thing we'll study is the building blocks of code.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Istruzioni
 
 Le istruzioni sono dei costrutti sintattici e comandi che eseguono azioni.
 
+<<<<<<< HEAD
 Abbiamo già visto un'istruzione `alert('Hello, world!')`, che mostra il messaggio "Hello world!".
 
 All'interno del codice possiamo avere tutte le istruzioni che desideriamo. Una seconda istruzione può essere separata tramite il punto e virgola.
 
 Ad esempio, qui dividiamo il messaggio in due:
+=======
+We've already seen a statement, `alert('Hello, world!')`, which shows the message "Hello, world!".
+
+We can have as many statements in our code as we want. Statements can be separated with a semicolon.
+
+For example, here we split "Hello World" into two alerts:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run no-beautify
 alert('Hello'); alert('World');
 ```
+<<<<<<< HEAD
 Di solito ogni istruzione viene scritta in una linea separata -- questo rende il codice molto più leggibile:
+=======
+
+Usually, statements are written on separate lines to make the code more readable:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run no-beautify
 alert('Hello');
@@ -33,11 +50,19 @@ alert('Hello')
 alert('World')
 ```
 
+<<<<<<< HEAD
 Qui JavaScript interpreta la fine della riga come un punto e virgola "implicito". Viene anche chiamato [automatic semicolon insertion](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion).
 
 **In molti casi la nuova riga viene interpretata come un punto e virgola implicito. Ma "in molti casi" non significa "sempre"!**
 
 Ci sono casi in cui la nuova riga non implica una punto e virgola, per esempio:
+=======
+Here, JavaScript interprets the line break as an "implicit" semicolon. This is called an [automatic semicolon insertion](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion).
+
+**In most cases, a newline implies a semicolon. But "in most cases" does not mean "always"!**
+
+There are cases when a newline does not mean a semicolon. For example:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run no-beautify
 alert(3 +
@@ -58,9 +83,15 @@ Se sei curioso di vedere un esempio concreto di questo tipo di errore, dai un oc
 [1, 2].forEach(alert)
 ```
 
+<<<<<<< HEAD
 Non c'e bisogno di pensare al significato delle parentesi `[]` e al `forEach`. Li studieremo più avanti, per ora non hanno importanza. Sappiate che il risultato mostra `1` e poi `2`.
 
 Adesso andiamo ad aggiungere un `alert` prima del codice e *non* concludiamo la riga con il punto e virgola:
+=======
+No need to think about the meaning of the brackets `[]` and `forEach` yet. We'll study them later. For now, just remember the result of the code: it shows `1` then `2`.
+
+Now, let's add an `alert` before the code and *not* finish it with a semicolon:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run no-beautify
 alert("There will be an error")
@@ -68,7 +99,11 @@ alert("There will be an error")
 [1, 2].forEach(alert)
 ```
 
+<<<<<<< HEAD
 Adesso se noi lo eseguiamo, solo il primo `alert` viene mostrato, poi avremmo un errore!
+=======
+Now if we run the code, only the first `alert` is shown and then we have an error!
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ma tutto si risolve se aggiungiamo un punto e virgola dopo `alert`:
 ```js run
@@ -77,27 +112,49 @@ alert("All fine now");
 [1, 2].forEach(alert)  
 ```
 
+<<<<<<< HEAD
 Adesso avremmo il messaggio "All fine now" e successivamente `1` seguito da `2`.
 
 L'errore nel non aver messo il punto e virgola è avvenuto perchè JavaScript non implica un punto e virgola prima delle parentesi quadre `[...]`.
 
 Quindi, poichè il punto e virgola non viene auto-inserito, il codice del precedente esempio viene trattato come un istruzione singola. Quindi il motore JavaScript lo vede cosi:
+=======
+Now we have the "All fine now" message followed by `1` and `2`.
+
+
+The error in the no-semicolon variant occurs because JavaScript does not assume a semicolon before square brackets `[...]`.
+
+So, because the semicolon is not auto-inserted, the code in the first example is treated as a single statement. Here's how the engine sees it:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run no-beautify
 alert("There will be an error")[1, 2].forEach(alert)
 ```
 
+<<<<<<< HEAD
 Anche se dovrebbero essere due istruzioni separate, non una singola. 
 But it should be two separate statements, not a single one. Questo tipo di unione, in questo caso è errata, quindi produce un errore. Ci sono altre situazioni in cui si verifica questo tipo di errore.
 ````
 
 E' consigliato quindi, di mettere il punto e virgola fra ogni istruzione, anche se vengono scritte in righe diverse. Questa regola è largamente adottata dalla community. Ripetiamolo nuovamente -- *è possibile* evitare di scrivere il punto e virgola la maggior parte delle volte. Ma è più sicuro -- specialmente per un beginner -- inserirle al termine di ogni istruzione.
+=======
+But it should be two separate statements, not one. Such a merging in this case is just wrong, hence the error. This can happen in other situations.
+````
+
+We recommend putting semicolons between statements even if they are separated by newlines. This rule is widely adopted by the community. Let's note once again -- *it is possible* to leave out semicolons most of the time. But it's safer -- especially for a beginner -- to use them.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Commenti
 
+<<<<<<< HEAD
 Con il passare del tempo, i programmi sono diventati sempre più complessi. E' diventato necessario aggiungere *commenti* che descrivessero i comportamenti del codice e il perchè.
 
 I commenti possono essere messi in qualsiasi punto dello script. Infatti non hanno alcun effetto sull'esecuzione del codice, poichè il motore JavaScript semplicemente li ignora.
+=======
+As time goes on, programs become more and more complex. It becomes necessary to add *comments* which describe what the code does and why.
+
+Comments can be put into any place of a script. They don't affect its execution because the engine simply ignores them.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 **I commenti su una singola linea incominciano con due caratteri di slash `//`.**
 
@@ -123,7 +180,13 @@ alert('Hello');
 alert('World');
 ```
 
+<<<<<<< HEAD
 Il contenuto dei commenti viene ignorato, quindi se inseriamo codice al suo interno <code>/&#42; ... &#42;/</code> non verrà eseguito.
+=======
+The content of comments is ignored, so if we put code inside <code>/&#42; ... &#42;/</code>, it won't execute.
+
+Sometimes it can be handy to temporarily disable a part of code:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Qualche volta diventa utile per bloccare temporaneamente qualche porzione di codice:
 ```js run
@@ -133,8 +196,13 @@ alert('Hello');
 alert('World');
 ```
 
+<<<<<<< HEAD
 ```smart header="Usa le scorciatoie da tastiera!"
 In molti editor una linea di codice può essere commentata con la combinazione da tastiera dei tasti `key:Ctrl+/` e una combinazione simile a `key:Ctrl+Shift+/` -- per i commenti multilinea (selezionate prima una parte di codice e poi utilizzate la combinazione di tasti). Su Mac dovrebbe funzionare la combinazione `key:Cmd` al posto di `key:Ctrl`.
+=======
+```smart header="Use hotkeys!"
+In most editors, a line of code can be commented out by pressing the `key:Ctrl+/` hotkey for a single-line comment and something like `key:Ctrl+Shift+/` -- for multiline comments (select a piece of code and press the hotkey). For Mac, try `key:Cmd` instead of `key:Ctrl`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ```
 
 ````warn header="I commenti annidati non sono supportati!"
@@ -151,6 +219,14 @@ alert( 'World' );
 ````
 Non abbiate paura di utilizzare i commenti nel codice.
 
+<<<<<<< HEAD
 I commenti aumenteranno il peso finale dello script, ma questo non sarà un problema. Ci sono tantissimi strumenti che possono minimizzare("minify") il codice prima di pubblicarlo nel server. Questi strumenti rimuovono i commenti, quindi non appariranno nello script che verrà eseguito. Perciò i commenti non hanno alcun effetto negativo sul codice prodotto.
 
 Inoltre più avanti nel tutorial ci sarà un capitolo <info:coding-style> che illustrerà come scrivere commenti in maniera ottimale.
+=======
+Please, don't hesitate to comment your code.
+
+Comments increase the overall code footprint, but that's not a problem at all. There are many tools which minify code before publishing to a production server. They remove comments, so they don't appear in the working scripts. Therefore, comments do not have negative effects on production at all.
+
+Later in the tutorial there will be a chapter <info:code-quality> that also explains how to write better comments.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/02-first-steps/03-strict-mode/article.md b/1-js/02-first-steps/03-strict-mode/article.md
index 3a3da6964..7dcbaefc4 100644
--- a/1-js/02-first-steps/03-strict-mode/article.md
+++ b/1-js/02-first-steps/03-strict-mode/article.md
@@ -1,5 +1,6 @@
 # Le tecniche moderne, "use strict"
 
+<<<<<<< HEAD
 Per molto tempo JavaScript si è evoluto senza problemi di compatibilità. Nuove funzionalità venivano aggiunte al linguaggio, ma quelle vecchie non cambiavano.
 
 Questo ha consentito al vecchio codice di non diventare obsoleto. Ma lo svantaggio è stato che cosi facendo gli errori e le decisioni imperefette fatte dai creatori di JavaScript, rimarranno nel linguaggio per sempre.
@@ -11,6 +12,19 @@ Cosi è stato fino al 2009 quando è apparsa ECMAScript 5 (ES5). Ha aggiungo nuo
 La direttiva è simile ad una stringa: `"use strict"` o `'use strict'`. Quando viene inserita all'inizio dello script, da quel momento l'intero script funziona nello stile "moderno".
 
 Per esempio:
+=======
+For a long time, JavaScript evolved without compatibility issues. New features were added to the language while old functionality didn't change.
+
+That had the benefit of never breaking existing code. But the downside was that any mistake or an imperfect decision made by JavaScript's creators got stuck in the language forever.
+
+This was the case until 2009 when ECMAScript 5 (ES5) appeared. It added new features to the language and modified some of the existing ones. To keep the old code working, most modifications are off by default. You need to explicitly enable them with a special directive: `"use strict"`.
+
+## "use strict"
+
+The directive looks like a string: `"use strict"` or `'use strict'`. When it is located at the top of a script, the whole script works the "modern" way.
+
+For example:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 "use strict";
@@ -21,16 +35,27 @@ Per esempio:
 
 Impareremo presto le funzioni(un modo per raggruppare le istruzioni).
 
+<<<<<<< HEAD
 Guardando avanti, notiamo che `"use strict"` può essere applicato all'inizio di una funzione(la maggior parte) piuttosto che all'intero script. La modalità strict sarà quindi attiva solo all'interno di quella funzione. Solitamente si utilizza nell'intero script.
+=======
+Looking ahead, let's just note that `"use strict"` can be put at the start of most kinds of functions instead of the whole script. Doing that enables strict mode in that function only. But usually, people use it for the whole script.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ````warn header="Assicurati che \"use strict\" sia all'inizio"
 Assicurati `"use strict"` sia all'inizio dello script, altrimenti la modalità script non verrà abilitata.
 
+<<<<<<< HEAD
 Qui non si attiva la modalità strict:
+=======
+````warn header="Ensure that \"use strict\" is at the top"
+Please make sure that `"use strict"` is at the top of your scripts, otherwise strict mode may not be enabled.
+
+Strict mode isn't enabled here:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js no-strict
 alert("some code");
-// "use strict" below is ignored, must be on the top
+// "use strict" below is ignored--it must be at the top
 
 "use strict";
 
@@ -40,14 +65,40 @@ alert("some code");
 Solo i commenti possono apparire prima di `"use strict"`.
 ````
 
+<<<<<<< HEAD
 ```warn header="Non c'e nessun modo per annullare `use strict`"
 Non esiste nessuna direttiva `"no use strict"` o simile, che possa riportare lo script alla vecchia modalità.
 
 Una volta abilitata la modalità strict, non c'e ritorno.
+=======
+```warn header="There's no way to cancel `use strict`"
+There is no directive like `"no use strict"` that reverts the engine to old behavior.
+
+Once we enter strict mode, there's no return.
+```
+
+## Browser console
+
+For the future, when you use a browser console to test features, please note that it doesn't `use strict` by default.
+
+Sometimes, when `use strict` makes a difference, you'll get incorrect results.
+
+Even if we press `key:Shift+Enter` to input multiple lines, and put `use strict` on top, it doesn't work. That's because of how the console executes the code internally.
+
+The reliable way to ensure `use strict` would be to input the code into console like this:
+
+```js
+(function() {
+  'use strict';
+
+  // ...your code...
+})()
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ```
 
 ## Usare sempre "use strict"
 
+<<<<<<< HEAD
 Le differenze tra `"use strict"` contro la modalità di "default" non è ancora stata spiegata.
 
 Nel prossimo capitolo, mentre impareremo le caratteristiche del linguaggio, terremo d'occhio anche le differenze tra la modalità strict e quella di default. Fortunatamente non sono molte. E senza dubbio renderanno migliore la scrittura del codice.
@@ -57,4 +108,16 @@ A questo punto è sufficiente sapere le regole generali:
 1. L'utilizzo della direttiva `"use strict"` cambia la modalità del motore JavaScript al il metodo moderno, cambiando i comportamenti di alcune caratteristiche integrate. Vedremo meglio i dettagli man mano che studiamo.
 2. La modalità strict viene abilitata tramite l'istruzione `"use strict"` posta all'inizio. In ogni caso ci sono alcune caratteristiche del linguaggio come "classi" e "moduli" che attivano la modalità strict in automatico.
 3. La modalità strict è supportata da tutti i moderni browser.
-4. E' sempre raccomandato iniziare lo script con `"use strict"`. Tutti gli esempi del tutorial assumo che esso sia attivo, tranne in alcuni esempi(veramente pochi) in cui verrà specificato esplicitamente.
\ No newline at end of file
+4. E' sempre raccomandato iniziare lo script con `"use strict"`. Tutti gli esempi del tutorial assumo che esso sia attivo, tranne in alcuni esempi(veramente pochi) in cui verrà specificato esplicitamente.
+=======
+We have yet to cover the differences between strict mode and the "default" mode.
+
+In the next chapters, as we learn language features, we'll note the differences between the strict and default modes. Luckily, there aren't many and they actually make our lives better.
+
+For now, it's enough to know about it in general:
+
+1. The `"use strict"` directive switches the engine to the "modern" mode, changing the behavior of some built-in features. We'll see the details later in the tutorial.
+2. Strict mode is enabled by placing `"use strict"` at the top of a script or function. Several language features, like "classes" and "modules", enable strict mode automatically.
+3. Strict mode is supported by all modern browsers.
+4. We recommended always starting scripts with `"use strict"`. All examples in this tutorial assume strict mode unless (very rarely) specified otherwise.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/02-first-steps/04-variables/2-declare-variables/task.md b/1-js/02-first-steps/04-variables/2-declare-variables/task.md
index 190d75c97..07bd26c54 100644
--- a/1-js/02-first-steps/04-variables/2-declare-variables/task.md
+++ b/1-js/02-first-steps/04-variables/2-declare-variables/task.md
@@ -4,5 +4,10 @@ importance: 3
 
 # Scegliere il giusto nome
 
+<<<<<<< HEAD
 1. Create una variabile con il nome del nostro pianeta. Come chiameresti questo tipo di variabile?
 2. Create una variabile che memorizza il nome del visitatore corrente. Come chiameresti questa variabile?
+=======
+1. Create a variable with the name of our planet. How would you name such a variable?
+2. Create a variable to store the name of a current visitor to a website. How would you name that variable?
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md
index 6ab3d6122..e2e35c1d3 100644
--- a/1-js/02-first-steps/04-variables/article.md
+++ b/1-js/02-first-steps/04-variables/article.md
@@ -1,16 +1,28 @@
 # Variabili
 
+<<<<<<< HEAD
 La maggior parte delle volte, le applicazioni JavaScript necessitano d'informazione per poter lavorare. Vediamo due esempi:
 1. Un negozio online -- le informazioni possono riguardare i beni venduti e il carrello.
 2. Un applicazione di messaggistica -- le informazioni possono riguardare utenti, messaggi e molto altro.
+=======
+Most of the time, a JavaScript application needs to work with information. Here are two examples:
+1. An online shop -- the information might include goods being sold and a shopping cart.
+2. A chat application -- the information might include users, messages, and much more.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Le variabili vengono utilizzate per memorizzare informazioni.
 
 ## Variabile
 
+<<<<<<< HEAD
 Una variabile [variable](https://en.wikipedia.org/wiki/Variable_(computer_science)) è un "memorizzatore con nome" per i dati. Possiamo usare le variabile per memorizzare informazioni extra, visitatori e altri dati.
 
 Per creare una variabile in JavaScript, dobbiamo utilizzare la parola chiave `let`.
+=======
+A [variable](https://en.wikipedia.org/wiki/Variable_(computer_science)) is a "named storage" for data. We can use variables to store goodies, visitors, and other data.
+
+To create a variable in JavaScript, use the `let` keyword.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 L'istruzione sotto crea(in altre parole: *dichiara* o *definisce*) una variabile identificata dal nome "messaggio":
 
@@ -18,7 +30,11 @@ L'istruzione sotto crea(in altre parole: *dichiara* o *definisce*) una variabile
 let message;
 ```
 
+<<<<<<< HEAD
 Adesso possiamo inserirci dati utilizzando l'operatore di assegnazione `=`:
+=======
+Now, we can put some data into it by using the assignment operator `=`:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 let message;
@@ -39,7 +55,11 @@ alert(message); // shows the variable content
 */!*
 ```
 
+<<<<<<< HEAD
 Per essere precisi, potremmo unire la dichiarazione e l'assegnazione in una singola riga:
+=======
+To be concise, we can combine the variable declaration and assignment into a single line:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let message = 'Hello!'; // define the variable and assign the value
@@ -53,7 +73,11 @@ Possiamo anche dichiarare più variabili in una riga:
 let user = 'John', age = 25, message = 'Hello';
 ```
 
+<<<<<<< HEAD
 Questo potrebbe risultare più breve, ma è sconsigliato. Per mantenere una migliore leggibilità è meglio utilizzare una riga per ogni variabile.
+=======
+That might seem shorter, but we don't recommend it. For the sake of better readability, please use a single line per variable.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 L'alternativa a più righe è un po più lunga, ma più facile da leggere:
 
@@ -63,7 +87,11 @@ let age = 25;
 let message = 'Hello';
 ```
 
+<<<<<<< HEAD
 Alcune persone scrivono variabili multiple in questo modo:
+=======
+Some people also define multiple variables in this multiline style:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ```js no-beautify
 let user = 'John',
   age = 25,
@@ -78,18 +106,32 @@ let user = 'John'
   , message = 'Hello';
 ```
 
+<<<<<<< HEAD
 Tecnicamente, tutte queste varianti fanno la stessa cosa. Quindi è una questione di gusto personale ed estetico.
 
 ````smart header="`var` piuttosto che `let`"
 Nei vecchi script potresti trovare: `var` piuttosto che `let`:
+=======
+Technically, all these variants do the same thing. So, it's a matter of personal taste and aesthetics.
+
+
+````smart header="`var` instead of `let`"
+In older scripts, you may also find another keyword: `var` instead of `let`:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 *!*var*/!* message = 'Hello';
 ```
 
+<<<<<<< HEAD
 La parola chiave `var` è *quasi* la stessa cosa di `let`. Dichiara comunque una variabile, ma in un maniera leggermente diversa, "vecchio stile".
 
 Ci sono delle sottili differenze tra `let` e `var`, ma per ora non hanno importanza. Le copriremo in dettaglio più avanti, nel capitolo <info:var>.
+=======
+The `var` keyword is *almost* the same as `let`. It also declares a variable, but in a slightly different, "old-school" way.
+
+There are subtle differences between `let` and `var`, but they do not matter for us yet. We'll cover them in detail in the chapter <info:var>.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ````
 
 ## Un analogia con il mondo reale
@@ -100,10 +142,15 @@ Per esempio, la variabile `message` può essere immaginata come una scatola con
 
 ![](variable.png)
 
+<<<<<<< HEAD
 Possiamo inserire qualsiasi valore all'interno della scatola.
 
 Possiamo ance cambiarlo. Il valore può cambiare tutte le volte che ne abbiamo bisogno:
+=======
+We can put any value in the box.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
+We can also change it as many times as we want:
 ```js run
 let message;
 
@@ -134,29 +181,51 @@ alert(hello); // Hello world!
 alert(message); // Hello world!
 ```
 
+<<<<<<< HEAD
 ```smart header="Linguaggi funzionali"
 Può essere interessante sapere che esistono anche linguaggi di programmazione [funzionale](https://en.wikipedia.org/wiki/Functional_programming) che vietano di cambiare il valore di una variabile. Per esempio, [Scala](http://www.scala-lang.org/) o [Erlang](http://www.erlang.org/).
+=======
+```smart header="Functional languages"
+It's interesting to note that [functional](https://en.wikipedia.org/wiki/Functional_programming) programming languages, like [Scala](http://www.scala-lang.org/) or [Erlang](http://www.erlang.org/), forbid changing variable values.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 In questo tipo di linguaggi, una volta che il valore viene memorizzato "dentro la scatola", ci rimane per sempre. Se abbiamo bisogno di memorizzare qualcos altro, il linguaggio ci forza a creare una nuova scatola (dichiarare una nuova variabile). Non possiamo quindi riutilizzare quelle vecchie.
 
+<<<<<<< HEAD
 Anche se potrebbero sembrare un pò strano a prima vista, questi linguaggi sono veramente capaci di sviluppare grandi cose. Inoltre, ci sono certe situazioni come calcoli paralleli in cui questi limiti portano dei benefici. Studiare un linguaggio di questo tipo (anche se non abbiamo intenzione di utilizzarlo a breve) è consigliato per allargare le proprie conoscenze.
+=======
+Though it may seem a little odd at first sight, these languages are quite capable of serious development. More than that, there are areas like parallel computations where this limitation confers certain benefits. Studying such a language (even if you're not planning to use it soon) is recommended to broaden the mind.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ```
 
 ## Nomi delle variabili [#variable-naming]
 
+<<<<<<< HEAD
 In JavaScript ci sono solo due limitazioni per il nome delle variabili:
 
 1. Il nome deve contenere solo lettere, numeri, simboli `$` e `_`.
 2. Il primo carattere non può essere un numero.
 
 Esempi di nomi validi:
+=======
+There are two limitations on variable names in JavaScript:
+
+1. The name must contain only letters, digits, or the symbols `$` and `_`.
+2. The first character must not be a digit.
+
+Examples of valid names:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 let userName;
 let test123;
 ```
 
+<<<<<<< HEAD
 Quando il nome contiene più parole, viene utilizzato il [camelCase](https://en.wikipedia.org/wiki/CamelCase). La logica è: le parole vanno una dopo l'altra, ogni parola inizia con lettere maiuscola: `myVeryLongName`.
+=======
+When the name contains multiple words, [camelCase](https://en.wikipedia.org/wiki/CamelCase) is commonly used. That is: words go one after another, each word starting with a capital letter: `myVeryLongName`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Una cosa interessante è che -- il simbolo del dollaro `'$'` e l'underscore `'_'` possono essere utilizzati nei nomi. Sono dei semplici simboli, come le lettere, senza alcun significato speciale.
 
@@ -174,11 +243,16 @@ Questi invece non lo sono:
 ```js no-beautify
 let 1a; // cannot start with a digit
 
-let my-name; // a hyphen '-' is not allowed in the name
+let my-name; // hyphens '-' aren't allowed in the name
 ```
 
+<<<<<<< HEAD
 ```smart header="La questione delle lettere"
 Le variabili `apple` ed `AppLE` -- sono due variabili distinte.
+=======
+```smart header="Case matters"
+Variables named `apple` and `AppLE` are two different variables.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ```
 
 ````smart header="Le lettere non inglesi sono permesse, ma sono sconsigliate"
@@ -192,10 +266,17 @@ let 我 = '...';
 Tecnicamente, non ci sono errori, questo tipo di nomi sono permessi, ma la tradizione internazionale è di utilizzare l'alfabeto inglese per il nome delle variabili. Anche se stiamo scrivendo un piccolo script, potrebbe infatti avere una lunga vita. Persone di altre nazionalità potrebbero aver bisogno di leggerlo.
 ````
 
+<<<<<<< HEAD
 ````warn header="Nomi riservati"
 C'e una [lista di parole riservate](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords), che non possono essere utilizzare come nomi di variabili, perchè vengono utilizzate dal linguaggio stesso.
 
 Per esempio, le parole `let`, `class`, `return`, `function` sono riservate.
+=======
+````warn header="Reserved names"
+There is a [list of reserved words](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords), which cannot be used as variable names because they are used by the language itself.
+
+For example: `let`, `class`, `return`, and `function` are reserved.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Questo codice provocherà un errore di sintassi:
 
@@ -207,17 +288,25 @@ let return = 5; // also can't name it "return", error!
 
 ````warn header="Un assegnazione senza `use strict`"
 
+<<<<<<< HEAD
 Normalmente, abbiamo bisogno di definire variabili prima di utilizzarle. Ma una volta, era possibile definire una variabile semplicemente assegnandogli un valore, senza `let`. Questo è ancora possibile se non utilizziamo `use strict`. E' necessario per mantenere la compatibilità con i vecchi script.
+=======
+Normally, we need to define a variable before using it. But in the old times, it was technically possible to create a variable by a mere assignment of the value without using `let`. This still works now if we don't put `use strict` in our scripts to maintain compatibility with old scripts.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run no-strict
 // note: no "use strict" in this example
 
-num = 5; // the variable "num" is created if didn't exist
+num = 5; // the variable "num" is created if it didn't exist
 
 alert(num); // 5
 ```
 
+<<<<<<< HEAD
 Però è una pessima pratica, se inseriamo "use script" provocherà un errore:
+=======
+This is a bad practice and would cause an error in strict mode:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 "use strict";
@@ -230,13 +319,21 @@ num = 5; // error: num is not defined
 
 ## Constanti
 
+<<<<<<< HEAD
 Per dichiarare una variabile costante(immutabile), dobbiamo utilizzare `const` invece di `let`:
+=======
+To declare a constant (unchanging) variable, use `const` instead of `let`:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 const myBirthday = '18.04.1982';
 ```
 
+<<<<<<< HEAD
 Le variabili dichiarate con `const` vengono chiamate "costanti". Non possono cambiare valore. Se tentassimo di farlo verrebbe sollevato un errore:
+=======
+Variables declared using `const` are called "constants". They cannot be changed. An attempt to do so would cause an error:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 const myBirthday = '18.04.1982';
@@ -245,7 +342,12 @@ myBirthday = '01.01.2001'; // error, can't reassign the constant!
 ```
 Quando il programmatore è sicuro che il valore della variabile non cambierà mai, può utilizzare `const` per soddisfare questa esigenza, e metterlo anche in mostra a tutti gli altri.
 
+<<<<<<< HEAD
 ### Le costanti maiuscole
+=======
+When a programmer is sure that a variable will never change, they can declare it with `const` to guarantee and clearly communicate that fact to everyone.
+
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Una pratica molto diffusa è di utilizzare le variabili costanti come alias di valori difficili da ricordare, e che sono noti prima dell'esecuzione.
 
@@ -266,6 +368,7 @@ alert(color); // #FF7F00
 
 Benefici:
 
+<<<<<<< HEAD
 - `COLOR_ORANGE` è più facile da ricordare di `"#FF7F00"`.
 - E' più facile commettere errori scrivendo `"#FF7F00"` piuttosto che `COLOR_ORANGE`.
 - Quando leggiamo il codice, `COLOR_ORANGE` è molto più significativo di `#FF7F00`.
@@ -273,6 +376,15 @@ Benefici:
 Quando dovremmo utilizzare lettere maiuscole per una costante, e quando invece trattarle come normali variabili? Facciamo un pò di chiarezza.
 
 Essere una "costante" significa che il valore non potrà mai cambiare. Ci sono costanti che sono note prima dell'esecuzione (come la codifia esadecimale del colore rosso), e ci sono quelle che vengono *calcolate* durante l'esecuzione, ma non cambieranno più dopo che gli sarà stato assegnato un valore.
+=======
+- `COLOR_ORANGE` is much easier to remember than `"#FF7F00"`.
+- It is much easier to mistype `"#FF7F00"` than `COLOR_ORANGE`.
+- When reading the code, `COLOR_ORANGE` is much more meaningful than `#FF7F00`.
+
+When should we use capitals for a constant and when should we name it normally? Let's make that clear.
+
+Being a "constant" just means that a variable's value never changes. But there are constants that are known prior to execution (like a hexadecimal value for red) and there are constants that are *calculated* in run-time, during the execution, but do not change after their initial assignment.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Per esempio:
 ```js
@@ -280,12 +392,19 @@ const pageLoadTime = /* time taken by a webpage to load */;
 ```
 Il valore di `pageLoadTime` non è noto prima del caricamento della pagina, quindi viene trattato come una normale variabile. Ma rimane comunque una costante, perchè non potrà più cambiare dopo che gli sarà stato assegnato un valore.
 
+<<<<<<< HEAD
 In altre parole, i nomi delle costanti in maiuscolo vengono utilizzati con variabili dal valore noto prima dell'esecuzione.
+=======
+The value of `pageLoadTime` is not known prior to the page load, so it's named normally. But it's still a constant because it doesn't change after assignment.
+
+In other words, capital-named constants are only used as aliases for "hard-coded" values.  
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Dare i giusti nomi alle cose
 
 Parlando di variabili, c'è un'altra cosa estremamente importante.
 
+<<<<<<< HEAD
 Per favore, utilizzate i nomi delle variabili con sensibilità. Prendetevi del tempo per pensare se necessario.
 
 Dare i giusti nomi alle variabili è una delle abilità più importanti (e difficili) nella programmazione. 
@@ -294,9 +413,19 @@ Una rapida occhiata ai nomi delle variabili può rivelare se il codice è stato
 In un progetto reale, la maggior parte del tempo lo si perde a modificare ed estendere del codice già esistente, piuttosto che riscriverne uno nuovo. E quando ritorneremo sul codice, dopo aver fatto qualcos'altro, sarà molto pù facile trovare informazioni se sono ben descritte. In altre parole, quando le variabili utilizzano dei nomi efficaci.
 
 Quindi è utile spendere del tempo a pensare il giusto nome per una variabile, prima di dichiararla. Questo approccio vi ripagherà.
+=======
+Please name your variables sensibly. Take time to think about this.
+
+Variable naming is one of the most important and complex skills in programming. A quick glance at variable names can reveal which code was written by a beginner versus an experienced developer.
+
+In a real project, most of the time is spent modifying and extending an existing code base rather than writing something completely separate from scratch. When we return to some code after doing something else for a while, it's much easier to find information that is well-labeled. Or, in other words, when the variables have good names.
+
+Please spend time thinking about the right name for a variable before declaring it. Doing so will repay you handsomely.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Alcune regole da seguire:
 
+<<<<<<< HEAD
 - Utilizzare nomi leggibili da persone, come `userName` o `shoppingCart`.
 - Evitate abbreviazioni o nomi brevi come `a`, `b`, `c`, senza che abbiano veramente senso.
 - Rendete il nome il più descrittivo e preciso possibile. Esempi di pessimi nomi sono `data` e `value`. Questo tipo di nomi non dicono niente. Si possono utilizzare eccezionalmente se il contesto rende esplicito il significato.
@@ -310,18 +439,45 @@ Come ultima cosa. Ci sono alcuni programmatori un pò pigri, che invece di dichi
 Il risultato che si ottiene, è che le variabili sono come delle scatole in cui si possono mettere varie cose, senza cambiare l'etichetta. Cosa ci sarà dentro in un dato momento? Chi lo sa... Siamo costretti a controllare manualmente.
 
 Questi programmatori risparmiano qualche bit nella dichiarazione delle variabili ma perdono dieci volte il tempo risparmiato per fare debugging del codice.
+=======
+- Use human-readable names like `userName` or `shoppingCart`.
+- Stay away from abbreviations or short names like `a`, `b`, `c`, unless you really know what you're doing.
+- Make names maximally descriptive and concise. Examples of bad names are `data` and `value`. Such names say nothing. It's only okay to use them if the context of the code makes it exceptionally obvious which data or value the variable is referencing.
+- Agree on terms within your team and in your own mind. If a site visitor is called a "user" then we should name related variables `currentUser` or `newUser` instead of `currentVisitor` or `newManInTown`.
+
+Sounds simple? Indeed it is, but creating descriptive and concise variable names in practice is not. Go for it.
+
+```smart header="Reuse or create?"
+And the last note. There are some lazy programmers who, instead of declaring new variables, tend to reuse existing ones.
+
+As a result, their variables are like boxes into which people throw different things without changing their stickers. What's inside the box now? Who knows? We need to come closer and check.
+
+Such programmers save a little bit on variable declaration but lose ten times more on debugging.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Una variable in più va bene, non sono il diavolo.
 
+<<<<<<< HEAD
 I browser moderni e JavaScript minimizzano ed ottimizzano il codice abbastanza bene, quindi non ci saranno problemi di performance. Usare variabili differenti, per valori differenti può addirittura aiutare il motore JavaScript nell'ottimizzazione.
+=======
+Modern JavaScript minifiers and browsers optimize code well enough, so it won't create performance issues. Using different variables for different values can even help the engine optimize your code.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ```
 
 ## Riepilogo
 
+<<<<<<< HEAD
 Possiamo dichiarare variabili per memorizzare dati. Possono essere dichiarate con `var`,`let` o `const`.
+=======
+We can declare variables to store data by using the `var`, `let`, or `const` keywords.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 - `let` -- è una dichiarazione delle variabili più moderna. Il codice deve essere in modalità strict per utilizzare `let` in Chrome (V8).
 - `var` -- è una dichiarazione delle variabili più vecchia-scuola. Normalmente non si dovrebbe utilizzare, spiegheremo le sottili differenze da `let` nel capitolo <info:var>, giusto per esserne a conoscenza.
 - `const` -- è simile a `let`, ma non consente di cambiare il valore della variabile.
 
+<<<<<<< HEAD
 Le variabili dovrebbero avere dei nomi che ci consentono di capire facilmente cosa c'è dentro.
+=======
+Variables should be named in a way that allows us to easily understand what's inside them.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/02-first-steps/04-variables/variable-change.png b/1-js/02-first-steps/04-variables/variable-change.png
index 6dd3803d9..9135e930a 100644
Binary files a/1-js/02-first-steps/04-variables/variable-change.png and b/1-js/02-first-steps/04-variables/variable-change.png differ
diff --git a/1-js/02-first-steps/04-variables/variable-change@2x.png b/1-js/02-first-steps/04-variables/variable-change@2x.png
index f57b04ab1..c9569e638 100644
Binary files a/1-js/02-first-steps/04-variables/variable-change@2x.png and b/1-js/02-first-steps/04-variables/variable-change@2x.png differ
diff --git a/1-js/02-first-steps/04-variables/variable.png b/1-js/02-first-steps/04-variables/variable.png
index ab532d91d..6d2482556 100644
Binary files a/1-js/02-first-steps/04-variables/variable.png and b/1-js/02-first-steps/04-variables/variable.png differ
diff --git a/1-js/02-first-steps/04-variables/variable@2x.png b/1-js/02-first-steps/04-variables/variable@2x.png
index c9c37f034..845f34408 100644
Binary files a/1-js/02-first-steps/04-variables/variable@2x.png and b/1-js/02-first-steps/04-variables/variable@2x.png differ
diff --git a/1-js/02-first-steps/05-types/article.md b/1-js/02-first-steps/05-types/article.md
index d7b7d7333..472cee390 100644
--- a/1-js/02-first-steps/05-types/article.md
+++ b/1-js/02-first-steps/05-types/article.md
@@ -1,6 +1,10 @@
 # Tipi di dato
 
+<<<<<<< HEAD
 Una variabile in JavaScript può contenere qualsiasi dato. Una variabile può essere di tipo stringa in un istante e successivamente ricevere un valore numerico:
+=======
+A variable in JavaScript can contain any data. A variable can at one moment be a string and at another be a number:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 // no error
@@ -10,7 +14,11 @@ message = 123456;
 
 I linguaggi di programmazione che lo consentono sono detti "dinamicamente tipati", questo significa che ci sono tipi di dato, ma le variabili non sono legate ad un tipo.
 
+<<<<<<< HEAD
 Ci sono sette tipi di dato in JavaScript. Qui ne studiamo le basi, nel prossimo capitolo lo entreremo nei dettagli.
+=======
+There are seven basic data types in JavaScript. Here, we'll cover them in general and in the next chapters we'll talk about each of them in detail.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Tipo Numerico
 
@@ -19,11 +27,19 @@ let n = 123;
 n = 12.345;
 ```
 
+<<<<<<< HEAD
 Il tipo *numerico* serve sia per i numeri interi che per quelli in virgola mobile.
 
 Ci sono varie operazioni disponibili con i numeri, ad esempio la moltiplicazione `*`, la divisione `/`, l'addizione `+`, la sottrazione `-` e molte altre.
 
 Oltre i normali numeri, ci sono anche i "valori numerici speciali" che appartengono sempre al tipo numerico: `Infinito`, `-Infinito` e `NaN`.
+=======
+The *number* type represents both integer and floating point numbers.
+
+There are many operations for numbers, e.g. multiplication `*`, division `/`, addition `+`, subtraction `-`, and so on.
+
+Besides regular numbers, there are so-called "special numeric values" which also belong to this data type: `Infinity`, `-Infinity` and `NaN`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 - `Infinito` rappresenta il concetto matematico [Infinito](https://en.wikipedia.org/wiki/Infinity) ∞. E' un valore speciale che è più grande di qualsiasi altro numero.
 
@@ -33,7 +49,11 @@ Oltre i normali numeri, ci sono anche i "valori numerici speciali" che apparteng
     alert( 1 / 0 ); // Infinity
     ```
 
+<<<<<<< HEAD
     O inserendolo direttamente nel codice:
+=======
+    Or just reference it directly:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
     ```js run
     alert( Infinity ); // Infinity
@@ -44,12 +64,17 @@ Oltre i normali numeri, ci sono anche i "valori numerici speciali" che apparteng
     alert( "not a number" / 2 ); // NaN, such division is erroneous
     ```
 
+<<<<<<< HEAD
     `NaN` è appiccicoso. Qualsiasi operazione su `NaN` restituirà `NaN`:
+=======
+    `NaN` is sticky. Any further operation on `NaN` returns `NaN`:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
     ```js run
     alert( "not a number" / 2 + 5 ); // NaN
     ```
 
+<<<<<<< HEAD
     Quindi, se è presente un `NaN` da qualche parte nell'operazione matematica, questo si propagherà fino al risultato.
 
 ```smart header="Le operazioni matematiche sono sicure"
@@ -59,12 +84,27 @@ Lo script non si interromperà mai con un errore fatale ("die"). Nel peggiore de
 ```
 
 I numeri con valore speciale appartengono formalmente al tipo "numerico". Ovviamente non sono numeri nel vero senso della parola.
+=======
+    So, if there's a `NaN` somewhere in a mathematical expression, it propagates to the whole result.
+
+```smart header="Mathematical operations are safe"
+Doing maths is "safe" in JavaScript. We can do anything: divide by zero, treat non-numeric strings as numbers, etc.
+
+The script will never stop with a fatal error ("die"). At worst, we'll get `NaN` as the result.
+```
+
+Special numeric values formally belong to the "number" type. Of course they are not numbers in the common sense of this word.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Vedremo di più su come lavorare con i numeri nel capitolo <info:number>.
 
 ## Tipo Stringa
 
+<<<<<<< HEAD
 Una stringa in JavaScript deve essere tra apici.
+=======
+A string in JavaScript must be surrounded by quotes.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 let str = "Hello";
@@ -92,9 +132,15 @@ alert( `Hello, *!*${name}*/!*!` ); // Hello, John!
 alert( `the result is *!*${1 + 2}*/!*` ); // the result is 3
 ```
 
+<<<<<<< HEAD
 L'espressione all'interno di `${…}` viene valutata ed il risultato diventa parte della stringa. Possiamo metterci qualsiasi cosa: una variabile come `name` oppure un espressione aritmetica come `1 + 2` o qualcosa di più complesso.
 
 Nota che questo è possibile sono tramite l'accento grave. Gli altri apici non lo consentono!
+=======
+The expression inside `${…}` is evaluated and the result becomes a part of the string. We can put anything in there: a variable like `name` or an arithmetical expression like `1 + 2` or something more complex.
+
+Please note that this can only be done in backticks. Other quotes don't have this embedding functionality!
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ```js run
 alert( "the result is ${1 + 2}" ); // the result is ${1 + 2} (double quotes do nothing)
 ```
@@ -128,31 +174,57 @@ let isGreater = 4 > 1;
 alert( isGreater ); // true (the comparison result is "yes")
 ```
 
+<<<<<<< HEAD
 Copriremo i valori booleani più in dettaglio nel capitolo <info:logical-operators>.
+=======
+We'll cover booleans more deeply in the chapter <info:logical-operators>.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Il valore "null"
 
+<<<<<<< HEAD
 Il valore speciale `null` non appartiene a nessun tipo di quelli descritti fino ad ora.
 
 Fa parte di un altro tipo, che contiene solo il valore `null`: 
+=======
+The special `null` value does not belong to any of the types described above.
+
+It forms a separate type of its own which contains only the `null` value:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 let age = null;
 ```
 
+<<<<<<< HEAD
 In JavaScript `null` non è un "riferimento ad un oggetto inesistente" o un "puntatore nullo" come in altri linguaggi.
 
 E' solamente un valore speciale che ha il senso di "nulla", "vuoto" o "valore sconosciuto".
 
 Il codice sopra indica che `age` è sconosciuto o vuoto per qualche motivo.
+=======
+In JavaScript, `null` is not a "reference to a non-existing object" or a "null pointer" like in some other languages.
+
+It's just a special value which represents "nothing", "empty" or "value unknown".
+
+The code above states that `age` is unknown or empty for some reason.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Il valore "undefined" 
 
+<<<<<<< HEAD
 Il valore speciale `undefined` vive a parte. Fa da tipo a se stesso, proprio come `null`.
+=======
+The special value `undefined` also stands apart. It makes a type of its own, just like `null`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Il significato di `undefined` è che "il valore non è assegnato".
 
+<<<<<<< HEAD
 Se una variabile viene dichiarata, ma non assegnata, il suo valore è esattamente `undefined`:
+=======
+If a variable is declared, but not assigned, then its value is `undefined`:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let x;
@@ -170,26 +242,47 @@ x = undefined;
 alert(x); // "undefined"
 ```
 
+<<<<<<< HEAD
 ...Ma non è comunque consigliabile farlo. Normalmente, si utilizza `null` per descrivere un valore "vuoto" o "sconosciuto" della variabile, e `undefined` viene utilizzato solo per i controlli, per verificare se la variabile è stata assegnata.
+=======
+...But we don't recommend doing that. Normally, we use `null` to assign an "empty" or "unknown" value to a variable, and we use `undefined` for checks like seeing if a variable has been assigned.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Oggetti e Simboli
 
 Il tipo `object` è speciale.
 
+<<<<<<< HEAD
 Tutti gli altri tipi descritti sono chiamati "primitivi", perchè i loro valori possono contenere solo una cosa (può essere una stringa, un numero o altro). Invece, gli oggetti vengono utilizzati per memorizzare una collezione di dati ed entità più complesse. Li tratteremo nel capitolo <info:object> dopo avere appreso abbastanza sui tipi primitivi.
 
 Il tipo `symbol` viene utilizzato per creare identificatori unici per gli oggetti. Li abbiamo citati per completezza, ma è meglio studiarli dopo aver compreso gli oggetti.
+=======
+All other types are called "primitive" because their values can contain only a single thing (be it a string or a number or whatever). In contrast, objects are used to store collections of data and more complex entities. We'll deal with them later in the chapter <info:object> after we learn more about primitives.
+
+The `symbol` type is used to create unique identifiers for objects. We have to mention it here for completeness, but it's better to study this type after objects.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## L'operatore typeof [#type-typeof]
 
+<<<<<<< HEAD
 L'operatore `typeof` ritorna il tipo dell'argomento. E' utile quando vogliamo lavorare con valori di tipi differenti, o per eseguire controlli rapidi.
+=======
+The `typeof` operator returns the type of the argument. It's useful when we want to process values of different types differently or just want to do a quick check.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Sono supportate due sintassi:
 
+<<<<<<< HEAD
 1. Come operatore: `typeof x`.
 2. Come funzione: `typeof(x)`.
 
 In altre parole, funziona sia con le parentesi che senza. Il risultato è lo stesso.
+=======
+1. As an operator: `typeof x`.
+2. As a function: `typeof(x)`.
+
+In other words, it works with parentheses or without them. The result is the same.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Una chiamata a `typeof x` ritorna una stringa con il nome del tipo:
 
@@ -217,11 +310,19 @@ typeof alert // "function"  (3)
 */!*
 ```
 
+<<<<<<< HEAD
 Le ultime tre linee potrebbero richiedere una spiegazione ulteriore:
 
 1. `Math` è un oggetto integrato che fornisce operazioni matematiche avanzate. Lo studieremo nel capitolo <info:number>. Qui ha il semplice scopo di rappresentare un oggetto.
 2. Il risultato di `typerisulaof null` è `"object"`. Questo è errato. E' un errore ufficialmente riconosciuto del `typeof`, mantenuto per retro-compatibilità. Ovviamente, `null` non è un oggetto. E' un valore speciale che fa da tipo a se stesso. Quindi, nuovamente, questo è un errore del linguaggio.
 3. Il risultato di `typeof alert` è `"function"`, perchè `alert` è una funzione del linguaggio. Studieremo le funzioni nel prossimo capitolo, e vedremo che non c'e nessun tipo "funzione" nel linguaggio. Le funzioni appartengono al tipo oggetto. Ma `typeof` le tratta differentemente. Formalmente, è errato, ma molto utile nella pratica.
+=======
+The last three lines may need additional explanation:
+
+1. `Math` is a built-in object that provides mathematical operations. We will learn it in the chapter <info:number>. Here, it serves just as an example of an object.
+2. The result of `typeof null` is `"object"`. That's wrong. It is an officially recognized error in `typeof`, kept for compatibility. Of course, `null` is not an object. It is a special value with a separate type of its own. So, again, this is an error in the language.
+3. The result of `typeof alert` is `"function"`, because `alert` is a function of the language. We'll study functions in the next chapters where we'll see that there's no special "function" type in JavaScript. Functions belong to the object type. But `typeof` treats them differently. Formally, it's incorrect, but very convenient in practice.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Riepilogo
 
@@ -237,8 +338,18 @@ Ci sono 7 tipi base in JavaScript.
 
 L'operatore `typeof` ci consente di vedere quale tipo è memorizzato nella variabile.
 
+<<<<<<< HEAD
 - Due forme: `typeof x` o `typeof(x)`.
 - Ritorna una stringa con il nome del tipo, come `"string"`.
 - Il valore `null` ritorna `"object"` -- è un errore del linguaggio, infatti non è un oggetto.
 
 Nel prossimo capitolo ci concentreremo nei tipi primitivi e quando avremo preso familiarità, passeremo agli oggetti.
+=======
+The `typeof` operator allows us to see which type is stored in a variable.
+
+- Two forms: `typeof x` or `typeof(x)`.
+- Returns a string with the name of the type, like `"string"`.
+- For `null` returns `"object"` -- this is an error in the language, it's not actually an object.
+
+In the next chapters, we'll concentrate on primitive values and once we're familiar with them, we'll move on to objects.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md b/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md
index 76063a438..fe083a7aa 100644
--- a/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md
+++ b/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md
@@ -10,13 +10,22 @@ true + false = 1
 "4" - 2 = 2
 "4px" - 2 = NaN
 7 / 0 = Infinity
-" -9\n" + 5 = " -9\n5"
-" -9\n" - 5 = -14
-null + 1 = 1 // (3)
-undefined + 1 = NaN // (4)
+" -9  " + 5 = " -9  5" // (3)
+" -9  " - 5 = -14 // (4)
+null + 1 = 1 // (5)
+undefined + 1 = NaN // (6)
 ```
 
+<<<<<<< HEAD
 1. L'addizione con una stringa di `"" + 1` converte `1` a stringa: `"" + 1 = "1"`, successivamente in `"1" + 0`, viene applicatala stessa regola.
 2. La sottrazione `-` (come la maggior parte delle operazioni matematiche) funzionano solo con i numeri, converte quindi una stringa vuota `""` in `0`.
 3. `null` diventa `0` dopo la conversione numerica.
 4. `undefined` diventa `NaN` dopo la conversione numerica.
+=======
+1. The addition with a string `"" + 1` converts `1` to a string: `"" + 1 = "1"`, and then we have `"1" + 0`, the same rule is applied.
+2. The subtraction `-` (like most math operations) only works with numbers, it converts an empty string `""` to `0`.
+3. The addition with a string appends the number `5` to the string.
+4. The subtraction always converts to numbers, so it makes `"  -9  "` a number `-9` (ignoring spaces around it).
+5. `null` becomes `0` after the numeric conversion.
+6. `undefined` becomes `NaN` after the numeric conversion.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/task.md b/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/task.md
index 9dae99edd..bc183f2a4 100644
--- a/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/task.md
+++ b/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/task.md
@@ -17,8 +17,8 @@ true + false
 "4" - 2
 "4px" - 2
 7 / 0
-"  -9\n" + 5
-"  -9\n" - 5
+"  -9  " + 5
+"  -9  " - 5
 null + 1
 undefined + 1
 ```
diff --git a/1-js/02-first-steps/06-type-conversions/article.md b/1-js/02-first-steps/06-type-conversions/article.md
index 88b71fd90..5946a637f 100644
--- a/1-js/02-first-steps/06-type-conversions/article.md
+++ b/1-js/02-first-steps/06-type-conversions/article.md
@@ -1,13 +1,24 @@
 # Conversione di tipi
 
+<<<<<<< HEAD
  Nella maggior parte dei casi, operatori e funzioni convertono automaticamente il valore nel tipo corretto. Questo viene detto "conversione di tipi".
+=======
+Most of the time, operators and functions automatically convert the values given to them to the right type. This is called "type conversion".
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio, `alert` converte automaticamente un valore qualsiasi in una stringa, per poterla mostrare. Le operazioni matematica convertono i valori in numeri.
 
+<<<<<<< HEAD
 Ci sono anche casi in cui è necessario convertire esplicitamente i valori per poter non provocare errori.
 
 ```smart header="Non parliamo ancora di oggetti"
 In questo capitolo non parleremo ancora di oggetti. Ci dedicheremo ai tipi primitivi. Successivamente, dopo aver capito gli oggetti, capire come funziona la conversione di oggetti, nel capitolo <info:object-toprimitive>.
+=======
+There are also cases when we need to explicitly convert a value to the expected type.
+
+```smart header="Not talking about objects yet"
+In this chapter, we won't cover objects. Instead, we'll study primitives first. Later, after we learn about objects, we'll see how object conversion works in the chapter <info:object-toprimitive>.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ```
 
 ## ToString
@@ -16,7 +27,11 @@ La conversione in stringa è utile quando abbiamo bisogno del formato stringa di
 
 Ad esempio, `alert(value)` effettua questa conversione per mostrare il valore.
 
+<<<<<<< HEAD
 Possiamo anche utilizzare la funzione `String(value)`, per ottenere un risultato simile:
+=======
+We can also call the `String(value)` function to convert a value to a string:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let value = true;
@@ -28,7 +43,11 @@ alert(typeof value); // string
 */!*
 ```
 
+<<<<<<< HEAD
 La conversione in stringa è quella più ovvia. Il valore `false` diventa la stringa `"false"`, mentre `null` diventa `"null"` etc.
+=======
+String conversion is mostly obvious. A `false` becomes `"false"`, `null` becomes `"null"`, etc.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## ToNumber
 
@@ -39,8 +58,13 @@ Ad esempio, quando la divisione `/` viene applicata ad un tipo non numerico:
 ```js run
 alert( "6" / "2" ); // 3, strings are converted to numbers
 ```
+<<<<<<< HEAD
 funzine
 Possiamo utilizzare la funzione `Number(value)` per convertire esplicitamente un valore `value`:
+=======
+
+We can use the `Number(value)` function to explicitly convert a `value` to a number:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let str = "123";
@@ -51,9 +75,15 @@ let num = Number(str); // becomes a number 123
 alert(typeof num); // number
 ```
 
+<<<<<<< HEAD
 Una conversione esplicita è solitamente richiesta quando leggiamo un valore da una risorsa di tipo stringa, come un form testuale, ma ci aspettiamo l'inserimento di un numero.
 
 Se la stringa non risulta essere un numero valido, il risultato della conversione sarà `NaN`, ad esempio:
+=======
+Explicit conversion is usually required when we read a value from a string-based source like a text form but expect a number to be entered.
+
+If the string is not a valid number, the result of such a conversion is `NaN`. For instance:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let age = Number("an arbitrary string instead of a number");
@@ -67,8 +97,13 @@ Le regole di conversione numerica:
 |-------|-------------|
 |`undefined`|`NaN`|
 |`null`|`0`|
+<<<<<<< HEAD
 |<code>true&nbsp;e&nbsp;false</code> | `1` e `0` |
 | `string` | Gli spazi bianchi dall'inizio e dalla fine vengono rimossi. Poi, se il resto della stringa è vuota, il risultato è `0`. Altrimenti, il numero viene "letto" dalla stringa. Un errore restituirà `NaN`. |
+=======
+|<code>true&nbsp;and&nbsp;false</code> | `1` and `0` |
+| `string` | Whitespaces from the start and end are removed. If the remaining string is empty, the result is `0`. Otherwise, the number is "read" from the string. An error gives `NaN`. |
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Esempi:
 
@@ -79,31 +114,53 @@ alert( Number(true) );        // 1
 alert( Number(false) );       // 0
 ```
 
+<<<<<<< HEAD
 Nota che `null` e `undefined` si comportano diversamente: `null` diventa zero, mentre `undefined` diventa `NaN`.
 
 ````smart header="L'addizione '+' concatena le stringhe"
 Quasi tutte le operazioni matematiche convertono valori in numeri. Con un importante eccezione per l'addizione `+`. Se uno degli operandi è una stringa, allora anche gli altri vengono convertiti in stringhe.
 
 E successivamente li concatena (unisce):
+=======
+Please note that `null` and `undefined` behave differently here: `null` becomes zero while `undefined` becomes `NaN`.
+
+````smart header="Addition '+' concatenates strings"
+Almost all mathematical operations convert values to numbers. A notable exception is addition `+`. If one of the added values is a string, the other one is also converted to a string.
+
+Then, it concatenates (joins) them:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 alert( 1 + '2' ); // '12' (string to the right)
 alert( '1' + 2 ); // '12' (string to the left)
 ```
 
+<<<<<<< HEAD
 Questo accade solo quando almeno uno degli argomenti è di tipo stringa. Altrimenti, i valori vengono convertiti in numeri
+=======
+This only happens when at least one of the arguments is a string. Otherwise, values are converted to numbers.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ````
 
 ## ToBoolean
 
 La conversione booleana è quella più semplice.
 
+<<<<<<< HEAD
 Questa si verifica con le operazioni logiche (più avanti incontreremo i testi di condizione ed altri tipi di operazione logiche), ma può anche essere richiamato manualmente con la funzione `Boolean(value)`.
+=======
+It happens in logical operations (later we'll meet condition tests and other similar things) but can also be performed explicitly with a call to `Boolean(value)`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Le regole di conversione:
 
+<<<<<<< HEAD
 - I valori che sono intuitivamente "vuoti", come lo `0`, una stringa vuota, `null`, `undefined` e `NaN` diventano `false`.
 - Gli altri valori diventano `true`.
+=======
+- Values that are intuitively "empty", like `0`, an empty string, `null`, `undefined`, and `NaN`, become `false`.
+- Other values become `true`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -115,8 +172,13 @@ alert( Boolean("hello") ); // true
 alert( Boolean("") ); // false
 ```
 
+<<<<<<< HEAD
 ````warn header="Da notare: una stringa contenente `\"0\"` viene valutata come `true`"
 Alcun linguaggi (come il PHP) trattano `"0"` come `false`. Diversamente in JavaScript una stringa non vuota è sempre `true`.
+=======
+````warn header="Please note: the string with zero `\"0\"` is `true`"
+Some languages (namely PHP) treat `"0"` as `false`. But in JavaScript, a non-empty string is always `true`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 alert( Boolean("0") ); // true
@@ -127,11 +189,19 @@ alert( Boolean(" ") ); // spaces, also true (any non-empty string is true)
 
 ## Riepilogo
 
+<<<<<<< HEAD
 I tre tipi di conversioni più utilizzati sono: a *string*, a *number* e a *boolean*.
 
 **`ToString`** -- Avviene quando stampiamo qualcosa a schermo, può essere richiamato con `String(value)`. La conversione a stringa è solitamente ovvia per i valore primitivi.
 
 **`ToNumber`** -- Utilizzata nelle operazioni matematiche, può essere richiamata esplicitamente con `Number(value)`.
+=======
+The three most widely used type conversions are to string, to number, and to boolean.
+
+**`ToString`** -- Occurs when we output something. Can be performed with `String(value)`. The conversion to string is usually obvious for primitive values.
+
+**`ToNumber`** -- Occurs in math operations. Can be performed with `Number(value)`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 La conversione segue le seguenti regole:
 
@@ -142,7 +212,11 @@ La conversione segue le seguenti regole:
 |<code>true&nbsp;/&nbsp;false</code> | `1 / 0` |
 | `string` | La stringa viene letta per "com'è", gli spazi bianchi agli estremi vengono ignorati. Una stringa vuota diventa `0`. Un errore restituisce `NaN`. |
 
+<<<<<<< HEAD
 **`ToBoolean`** -- Avviene nelle operazioni logiche, può anche essere richiamato esplicitamente con `Boolean(value)`.
+=======
+**`ToBoolean`** -- Occurs in logical operations. Can be performed with `Boolean(value)`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Segue le regole:
 
@@ -157,4 +231,8 @@ La maggior parte di queste regole sono facili da capire e memorizzare. Gli error
 - `undefined` vale `NaN` come un numero, non `0`.
 - `"0"` e le stringhe che contengono solamente spazi `"   "` vengono interpretate come true.
 
+<<<<<<< HEAD
 Qui non abbiamo coperto gli oggetti, ci ritorneremo più avanti nel capitolo <info:object-toprimitive> che è dedicato esclusivamente agli oggetti, dopo che avremmo imparato più cose basilari su JavaScript.
+=======
+Objects aren't covered here. We'll return to them later in the chapter <info:object-toprimitive> that is devoted exclusively to objects after we learn more basic things about JavaScript.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/02-first-steps/07-operators/article.md b/1-js/02-first-steps/07-operators/article.md
index 592857f91..cc9ffe082 100644
--- a/1-js/02-first-steps/07-operators/article.md
+++ b/1-js/02-first-steps/07-operators/article.md
@@ -1,15 +1,28 @@
 # Operatori
 
+<<<<<<< HEAD
 Molti operatori già li conosciamo dalle scuole. Tra cui l'addizione `+`, la moltiplicazione `*`, la sottrazione `-` e molti altri.
 
 In questo capitolo ci concentreremo sugli aspetti che non vengono descritti a scuola.
+=======
+We know many operators from school. They are things like addition `+`, multiplication `*`, subtraction `-`, and so on.
+
+In this chapter, we'll concentrate on aspects of operators that are not covered by school arithmetic.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Termini: "unario", "binario", "operando"
 
+<<<<<<< HEAD
 Prima di procedere, cerchiamo di capire la terminologia.
 
 - *Un operando* -- è quello su cui si applica l'operatore. Ad esempio nella moltiplicazione `5 * 2` ci sono due operandi: l'operando sinistro cioè il `5`, e l'operando di destra cioè il `2`. Qualche volta le persone dicono "argomenti" piuttosto che "operandi".
 - Un operatore è *unario* se ha un singolo operando. Ad esempio, la negazione `-` inverte il segno di un numero:
+=======
+Before we move on, let's grasp some common terminology.
+
+- *An operand* -- is what operators are applied to. For instance, in the multiplication of `5 * 2` there are two operands: the left operand is `5` and the right operand is `2`. Sometimes, people call these "arguments" instead of "operands".
+- An operator is *unary* if it has a single operand. For example, the unary negation `-` reverses the sign of a number:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
     ```js run
     let x = 1;
@@ -19,13 +32,18 @@ Prima di procedere, cerchiamo di capire la terminologia.
     */!*
     alert( x ); // -1, unary negation was applied
     ```
+<<<<<<< HEAD
 - Un operatore è *binario* se ha due operandi. Lo stesso operatore "meno" esiste nella forma binaria:
+=======
+- An operator is *binary* if it has two operands. The same minus exists in binary form as well:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
     ```js run no-beautify
     let x = 1, y = 3;
     alert( y - x ); // 2, binary minus subtracts values
     ```
 
+<<<<<<< HEAD
     Formalmente, stiamo parlando di due operatori diversi: la negazione unaria (un singolo operando, inverte il segno) e la sottrazione binaria (due operandi, si esegue la sottrazione).
 
 ##  Concatenazione di stringhe, operatore binario +
@@ -35,13 +53,28 @@ Adesso diamo un'occhiata alle caratteristiche degli operatori in JavaScript, che
 L'operatore di somma `+` viene utilizzato per sommare due numeri.
 
 Ma se l'operatore binario `+` viene applicato a delle stringhe, queste verranno unite (concatenate):
+=======
+    Formally, we're talking about two different operators here: the unary negation (single operand: reverses the sign) and the binary subtraction (two operands: subtracts).
+
+## String concatenation, binary +
+
+Now, let's see special features of JavaScript operators that are beyond school arithmetics.
+
+Usually, the plus operator `+` sums numbers.
+
+But, if the binary `+` is applied to strings, it merges (concatenates) them:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 let s = "my" + "string";
 alert(s); // mystring
 ```
 
+<<<<<<< HEAD
 Nota che se almeno uno degli operandi è una stringa, anche gli altri verrano convertiti a stringa.
+=======
+Note that if one of the operands is a string, the other one is converted to a string too.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -50,7 +83,11 @@ alert( '1' + 2 ); // "12"
 alert( 2 + '1' ); // "21"
 ```
 
+<<<<<<< HEAD
 Come hai visto, non è importante se la stringa è il primo operando o il secondo. La regola è semplice: se uni degli operandi è una stringa, anche gli altri vengono convertiti a stringa.
+=======
+See, it doesn't matter whether the first operand is a string or the second one. The rule is simple: if either operand is a string, the other one is converted into a string as well.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Comunque, queste operazioni vengono eseguite da sinistra verso destra, Se ci sono due numeri prima di una stringa, prima vengono sommati e il risultato convertito in stringa:
 
@@ -59,7 +96,11 @@ Comunque, queste operazioni vengono eseguite da sinistra verso destra, Se ci son
 alert(2 + 2 + '1' ); // "41" and not "221"
 ```
 
+<<<<<<< HEAD
 La concatenazione di stringhe e la conversione è una caratteristica particolare dell'operatore binario `+`. Gli altri operatori aritmetici funzionano solamente con i numeri. Infatti convertono sempre i loro operandi a numeri.
+=======
+String concatenation and conversion is a special feature of the binary plus `+`. Other arithmetic operators work only with numbers and always convert their operands to numbers.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio, la sottrazione e la divisione:
 
@@ -70,9 +111,15 @@ alert( '6' / '2' ); // 3
 
 ## Conversione numerica, operatore unario +
 
+<<<<<<< HEAD
 L'operatore somma `+` esiste in due forme. La forma binaria che abbiamo utilizzato sopra, e quella unaria.
 
 L'operatore unario di somma `+` viene applicato ad un singolo valore, non fa nulla con i numero, ma se l'operando non è un numero, viene convertito in un operando di tipo numerico.
+=======
+The plus `+` exists in two forms: the binary form that we used above and the unary form.
+
+The unary plus or, in other words, the plus operator `+` applied to a single value, doesn't do anything to numbers. But if the operand is not a number, the unary plus converts it into a number.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -91,9 +138,15 @@ alert( +"" );   // 0
 */!*
 ```
 
+<<<<<<< HEAD
 Si ottiene lo stesso risultato di `Number(...)`, ma in un modo più veloce.
 
 La necessità di convertire stringhe in numeri si presenta molto spesso. Ad esempio, se stiamo prelevando un valore da un campo HTML, questo solitamente sarà di tipo stringa.
+=======
+It actually does the same thing as `Number(...)`, but is shorter.
+
+The need to convert strings to numbers arises very often. For example, if we are getting values from HTML form fields, they are usually strings.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Come procedere in caso volessimo sommare questi valori?
 
@@ -106,7 +159,11 @@ let oranges = "3";
 alert( apples + oranges ); // "23", the binary plus concatenates strings
 ```
 
+<<<<<<< HEAD
 Se invece vogliamo trattarli come numeri, possiamo prima convertirli e successivamente sommarli:
+=======
+If we want to treat them as numbers, we need to convert and then sum them:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let apples = "2";
@@ -121,6 +178,7 @@ alert( +apples + +oranges ); // 5
 // alert( Number(apples) + Number(oranges) ); // 5
 ```
 
+<<<<<<< HEAD
 Dal punto di vista di matematico l'abbondanza di operatori di somma può risultare strano. Diversamente, dal punto di vista informatico, non c'e nulla di speciale: la somma unaria viene applicata per prima, si occupa di convertire stringhe in numeri, successivamente la somma binaria esegue l'addizione.
 
 Perchè la somma unaria viene applicata prima di quella binaria? Come adesso vedremo, questo accade per via della *precedenza maggiore*.
@@ -136,6 +194,23 @@ Le parentesi, superano qualsiasi precedenza, quindi se non siamo soddisfatti del
 Ci sono molti operatori in JavaScript. Ogni operatore ha un suo grado di precedenza. Quello con il grado più elevato viene eseguito per primo. Se il grado di precedenza è uguale si esegue da sinistra a destra.
 
 Un estratto della [tabella delle precedenze](https://developer.mozilla.org/en/JavaScript/Reference/operators/operator_precedence) (non è necessario che ve la ricordiate, ma tenete a mente che gli operatori unari hanno una precedenza più elevata rispetto ai corrispondenti binari):
+=======
+From a mathematician's standpoint, the abundance of pluses may seem strange. But from a programmer's standpoint, there's nothing special: unary pluses are applied first, they convert strings to numbers, and then the binary plus sums them up.
+
+Why are unary pluses applied to values before the binary ones? As we're going to see, that's because of their *higher precedence*.
+
+## Operator precedence
+
+If an expression has more than one operator, the execution order is defined by their *precedence*, or, in other words, the implicit priority order of operators.
+
+From school, we all know that the multiplication in the expression `1 + 2 * 2` should be calculated before the addition. That's exactly the precedence thing. The multiplication is said to have *a higher precedence* than the addition.
+
+Parentheses override any precedence, so if we're not satisfied with the implicit order, we can use them to change it. For example: `(1 + 2) * 2`.
+
+There are many operators in JavaScript. Every operator has a corresponding precedence number. The one with the larger number executes first. If the precedence is the same, the execution order is from left to right.
+
+Here's an extract from the [precedence table](https://developer.mozilla.org/en/JavaScript/Reference/operators/operator_precedence) (you don't need to remember this, but note that unary operators are higher than corresponding binary ones):
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 | Precedence | Name | Sign |
 |------------|------|------|
@@ -150,13 +225,21 @@ Un estratto della [tabella delle precedenze](https://developer.mozilla.org/en/Ja
 | 3 | assignment | `=` |
 | ... | ... | ... |
 
+<<<<<<< HEAD
 Come possiamo vedere, la "somma unaria"(unary plus) ha una priorità di `16`, che è maggiore di `13` dell'addizione(somma binaria). Questo è il motivo per cui l'espressione `"+apples + +oranges"` esegue prima la somma unaria, e successivamente l'addizione.
+=======
+As we can see, the "unary plus" has a priority of `16` which is higher than the `13` of "addition" (binary plus). That's why, in the expression `"+apples + +oranges"`, unary pluses work before the addition.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Assegnazione
 
 Da notare che anche l'assegnazione `=` è un operatore. Viene infatti elencato nella tabella delle precedenze con una priorità molto bassa: `3`.
 
+<<<<<<< HEAD
 Questo è il motivo per cui quando assegniamo un valore ad una variabile, come `x = 2 * 2 + 1`, i calcoli vengono eseguiti per primi, e successivamente viene valutato l'operatore `=`, che memorizza il risultato in `x`.
+=======
+That's why, when we assign a variable, like `x = 2 * 2 + 1`, the calculations are done first and then the `=` is evaluated, storing the result in `x`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 let x = 2 * 2 + 1;
@@ -178,14 +261,25 @@ alert( b ); // 4
 alert( c ); // 4
 ```
 
+<<<<<<< HEAD
 Le assegnazioni concatenate vengono valutate da destra a sinistra. Prima viene valutata l'espressione più a destra `2 + 2` e successivamente viene valutata l'assegnazione a sinistra: `c`, `b` e `a`. Alla fine, tutte le variabili condivideranno lo stesso valore.
 
 ````smart header="L'operatore di assegnazione`\"=\"` ritorna un valore"
 Un operatore ritorna sempre un valore. Questo è ovvio per molti operatori come l'addizione `+` o la moltiplicazione `*`. Ma anche l'operatore di assegnazione segue la stessa regola.
+=======
+Chained assignments evaluate from right to left. First, the rightmost expression `2 + 2` is evaluated and then assigned to the variables on the left: `c`, `b` and `a`. At the end, all the variables share a single value.
+
+````smart header="The assignment operator `\"=\"` returns a value"
+An operator always returns a value. That's obvious for most of them like addition `+` or multiplication `*`. But the assignment operator follows this rule too.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 La chiamata `x = value` scrive `value` dentro `x` *e successivamente la ritorna*.
 
+<<<<<<< HEAD
 Qui c'e una demo che usa un assegnazione come parte di un espressione più complessa:
+=======
+Here's a demo that uses an assignment as part of a more complex expression:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let a = 1;
@@ -201,12 +295,20 @@ alert( c ); // 0
 
 Nell'esempio qui sopra, il risultato di `(a = b + 1)` è il valore che viene assegnato ad `a` (che è `3`). Viene poi utilizzato per sottrarlo a `3`.
 
+<<<<<<< HEAD
 Sembra un codice strano, no? Dovremmo quindi capire perchè e come funzione, poichè potrete incontrarlo in alcune librerie di terze parti, anche se non dovreste mai scrivere nulla di simile. Queste scorciatoie non rendono per niente il codice pulito e leggibile.
+=======
+Funny code, isn't it? We should understand how it works, because sometimes we see it in 3rd-party libraries, but shouldn't write anything like that ourselves. Such tricks definitely don't make code clearer or readable.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ````
 
 ## Resto %
 
+<<<<<<< HEAD
 L'operatore di resto `%`, anche se può sembrare, non ha nulla a che fare con le percentuali.
+=======
+The remainder operator `%`, despite its appearance, is not related to percents.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Il risultato di `a % b` è il resto della divisione intera tra `a` e `b`.
 
@@ -232,7 +334,13 @@ alert( 2 ** 3 ); // 8  (2 * 2 * 2)
 alert( 2 ** 4 ); // 16 (2 * 2 * 2 * 2)
 ```
 
+<<<<<<< HEAD
 L'operatore funziona anche con valori non interi di `a` e `b`, ad esempio:
+=======
+The operator works for non-integer numbers as well.
+
+For instance:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 alert( 4 ** (1/2) ); // 2 (power of 1/2 is the same as a square root, that's maths)
@@ -245,7 +353,11 @@ alert( 8 ** (1/3) ); // 2 (power of 1/3 is the same as a cubic root)
 
 L'incremento o il decremento di un numero di uno è una delle operazioni numeriche più comuni.
 
+<<<<<<< HEAD
 Quindi, c'è un operatore speciale per questo:
+=======
+So, there are special operators for it:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 - **Incremento** `++` incrementa la variabile di 1:
 
@@ -263,6 +375,7 @@ Quindi, c'è un operatore speciale per questo:
     ```
 
 ```warn
+<<<<<<< HEAD
 L'Incremento/decremento possono essere applicati solo a variabili. Se tentiamo di utilizzarli con un valore, come `5++` verrà sollevato un errore.
 ```
 
@@ -272,12 +385,29 @@ Gli operatori `++` e `--` possono essere inseriti sia prima che dopo la variabil
 - La "forma pre-fissa" si ottiene inserendo l'operatore prima della variabile: `++counter`.
 
 Entrambi questi metodi portano allo stesso risultato: incrementano `counter` di `1`.
+=======
+Increment/decrement can only be applied to variables. Trying to use it on a value like `5++` will give an error.
+```
+
+The operators `++` and `--` can be placed either before or after a variable.
+
+- When the operator goes after the variable, it is in "postfix form": `counter++`.
+- The "prefix form" is when the operator goes before the variable: `++counter`.
+
+Both of these statements do the same thing: increase `counter` by `1`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 C'è qualche differenza? Si, ma possiamo notarla solo se andiamo ad utilizzare il valore di ritorno di `++/--`.
 
+<<<<<<< HEAD
 Facciamo chiarezza. Come sappiamo, tutti gli operatori ritornano un valore. L'incremento/decremento non fanno eccezione. La forma pre-fissa ritorna il nuovo valore, mentre la forma post-fissa ritorna il vecchio valore(prima dell'incremento/decremento).
 
 Per vedere le differenze, guardiamo un esempio:
+=======
+Let's clarify. As we know, all operators return a value. Increment/decrement is no exception. The prefix form returns the new value while the postfix form returns the old value (prior to increment/decrement).
+
+To see the difference, here's an example:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let counter = 1;
@@ -286,9 +416,15 @@ let a = ++counter; // (*)
 alert(a); // *!*2*/!*
 ```
 
+<<<<<<< HEAD
 Nella riga `(*)` la chiamata pre-fissa di `++counter` incrementa `counter` e ritorna il nuovo valore che è `2`. Quindi `alert` mostra `2`.
 
 Adesso proviamo ad utilizzare la forma post-fissa:
+=======
+In the line `(*)`, the *prefix* form `++counter` increments `counter` and returns the new value, `2`. So, the `alert` shows `2`.
+
+Now, let's use the postfix form:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let counter = 1;
@@ -297,11 +433,19 @@ let a = counter++; // (*) changed ++counter to counter++
 alert(a); // *!*1*/!*
 ```
 
+<<<<<<< HEAD
 Nella riga `(*)` la forma *post-fissa* `counter++` incrementa `counter`, ma ritorna il *vecchio* valore(prima dell'incremento). Quindi `alert` mostra `1`.
+=======
+In the line `(*)`, the *postfix* form `counter++` also increments `counter` but returns the *old* value (prior to increment). So, the `alert` shows `1`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Per ricapitolare:
 
+<<<<<<< HEAD
 - Se il risultato di un incremento/decremento non viene utilizzato, non ci sarà differenza qualsiasi forma venga utilizzata:
+=======
+- If the result of increment/decrement is not used, there is no difference in which form to use:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
     ```js run
     let counter = 0;
@@ -309,21 +453,34 @@ Per ricapitolare:
     ++counter;
     alert( counter ); // 2, the lines above did the same
     ```
+<<<<<<< HEAD
 - Se l'intenzione è di incrementare il valore *e* utilizzare il valore, allora si utilizza la forma pre-fissa:
+=======
+- If we'd like to increase a value *and* immediately use the result of the operator, we need the prefix form:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
     ```js run
     let counter = 0;
     alert( ++counter ); // 1
     ```
+<<<<<<< HEAD
 - Se si ha intenzione di incrementare, ma utilizzare il valore precedente, allora sarà necessario utilizzare la forma post-fissa:
+=======
+- If we'd like to increment a value but use its previous value, we need the postfix form:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
     ```js run
     let counter = 0;
     alert( counter++ ); // 0
     ```
 
+<<<<<<< HEAD
 ````smart header="Incremento/decremento contro gli operatori"
 Gli operatori `++/--` possono essere utilizzati nello stesso modo all'interno di un espressione. La loro precedenza sarà maggiore degli altri operatori aritmetici.
+=======
+````smart header="Increment/decrement among other operators"
+The operators `++/--` can be used inside expressions as well. Their precedence is higher than most other arithmetical operations.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -339,11 +496,19 @@ let counter = 1;
 alert( 2 * counter++ ); // 2, because counter++ returns the "old" value
 ```
 
+<<<<<<< HEAD
 Sebbene sia tecnicamente permesso, questa notazione rende il codice meno leggibile. Una linea che esegue più operazioni -- non è mai un bene.
 
 Mentre leggiamo il codice, una rapido scorrimento con lo sguardo in "verticale" può facilmente far saltare la lettura di un parte di codice, come ad esempio `counter++`, e potrebbe quindi non essere ovvio che la variabile incrementa.
 
 E' consigliato utilizzare lo stile "una linea -- un'azione":
+=======
+Though technically okay, such notation usually makes code less readable. One line does multiple things -- not good.
+
+While reading code, a fast "vertical" eye-scan can easily miss something like `counter++` and it won't be obvious that the variable increased.
+
+We advise a style of "one line -- one action":
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let counter = 1;
@@ -368,11 +533,19 @@ La lista degli operatori:
 - RIGHT SHIFT ( `>>` )
 - ZERO-FILL RIGHT SHIFT ( `>>>` )
 
+<<<<<<< HEAD
 Questi operatori vengono utilizzati raramente. Per capirli, dovremmo entrare nella rappresentazione dei numeri a basso livello, e non è questo il contesto per approfondirli. Specialmente perchè non ne avremmo bisogno presto. Se siete curiosi, potete leggere l'articolo sugli [operatori BitWise](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators) su MDN. Potrebbero essere molto utili in certe situazioni di necessità.
+=======
+These operators are used very rarely. To understand them, we need to delve into low-level number representation and it would not be optimal to do that right now, especially since we won't need them any time soon. If you're curious, you can read the [Bitwise Operators](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators) article on MDN. It would be more practical to do that when a real need arises.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Modifica-in-posizione
 
+<<<<<<< HEAD
 Abbiamo spesso necessità di applicare un operatore ad una variabile e memorizzare il nuovo risultato.
+=======
+We often need to apply an operator to a variable and store the new result in that same variable.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -382,7 +555,11 @@ n = n + 5;
 n = n * 2;
 ```
 
+<<<<<<< HEAD
 Questa notazione può essere accorciata utilizzando gli operatori `+=` e `*=`:
+=======
+This notation can be shortened using the operators `+=` and `*=`:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let n = 2;
@@ -392,7 +569,11 @@ n *= 2; // now n = 14 (same as n = n * 2)
 alert( n ); // 14
 ```
 
+<<<<<<< HEAD
 Gli operatori di abbreviazione "modifica-in-posizione" esistono per tutti gli operatori, anche per quelli bit a bit(bitwise): `/=`, `-=` etc.
+=======
+Short "modify-and-assign" operators exist for all arithmetical and bitwise operators: `/=`, `-=`, etc.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Questi operatori hanno la stessa precedenza di una normale assegnazione, quindi l'assegnazione verrà effettuata dopo gli altri calcoli:
 
@@ -406,9 +587,15 @@ alert( n ); // 16  (right part evaluated first, same as n *= 8)
 
 ## Virgola
 
+<<<<<<< HEAD
 L'operatore virgola `,` è uno degli operatori più rari ed inusuali. Qualche volta viene utilizzato per scrivere codice più breve, quindi è necessario capirlo bene per sapere cosa sta succedendo.
 
 L'operatore virgola ci consente di valutare diverse espressioni, dividendole con `,`. Ogni espressione viene valutata, ma solo dell'ultima viene ritornato il risultato.
+=======
+The comma operator `,` is one of the rarest and most unusual operators. Sometimes, it's used to write shorter code, so we need to know it in order to understand what's going on.
+
+The comma operator allows us to evaluate several expressions, dividing them with a comma `,`. Each of them is evaluated but only the result of the last one is returned.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -420,17 +607,30 @@ let a = (1 + 2, 3 + 4);
 alert( a ); // 7 (the result of 3 + 4)
 ```
 
+<<<<<<< HEAD
 Qui la prima espressione `1 + 2` viene valutata, ed il suo risultato viene scartato, successivamente viene eseguito `3 + 4` e il suo risultato viene ritornato.
+=======
+Here, the first expression `1 + 2` is evaluated and its result is thrown away. Then, `3 + 4` is evaluated and returned as the result.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```smart header="La virgola ha una precedenza molto bassa"
 L'operatore virgola ha una precedenza molto bassa, più bassa di `=`, quindi le parentesi sono importanti nel'esempio sopra.
 
+<<<<<<< HEAD
 Senza parentesi: `a = 1 + 2, 3 + 4` verrebbe valutato `+` prima, sommando i numeri in `a = 3, 7`, poi viene valutato l'operatore di assegnazione `=` che assegna `a = 3`, e successivamente il numero `7` dopo la virgola, che viene ignorato.
 ```
 
 Perchè dovremmo avere bisogno di un operatore che non ritorna nulla tranne l'ultima parte?
 
 Qualche volta le persone lo utilizzano in costrutti  più complessi per eseguire più azioni in una sola riga.
+=======
+Without them: `a = 1 + 2, 3 + 4` evaluates `+` first, summing the numbers into `a = 3, 7`, then the assignment operator `=` assigns    `a = 3`, and finally the number after the comma, `7`, is not processed so it's ignored.
+```
+
+Why do we need an operator that throws away everything except the last part?
+
+Sometimes, people use it in more complex constructs to put several actions in one line.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -441,4 +641,8 @@ for (*!*a = 1, b = 3, c = a * b*/!*; a < 10; a++) {
 }
 ```
 
+<<<<<<< HEAD
 Questo "trick" viene utilizzato in molti framework JavaScript, per questo l'abbiamo menzionato. Ma solitamente non migliora la leggibilità del codice, quindi dovremmo pensarci bene prima di scrivere questo tipo di espressioni.
+=======
+Such tricks are used in many JavaScript frameworks. That's why we're mentioning them. But, usually, they don't improve code readability so we should think well before using them.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/02-first-steps/08-comparison/article.md b/1-js/02-first-steps/08-comparison/article.md
index 7e110b6b0..ef1d2bb69 100644
--- a/1-js/02-first-steps/08-comparison/article.md
+++ b/1-js/02-first-steps/08-comparison/article.md
@@ -1,18 +1,34 @@
 # Confronti
 
+<<<<<<< HEAD
 Molti operatori di confronto li conosciamo già dalla matematica:
 
 - Maggiore/minore di: <code>a &gt; b</code>, <code>a &lt; b</code>.
 - Maggiore/minore o uguale di: <code>a &gt;= b</code>, <code>a &lt;= b</code>.
 - L'uguaglianza viene scritta come `a == b` (da notare che si utilizza due volte il simbolo `=`. Il simbolo unico`a = b` significa assegnazione).
 - Non uguale. In matematica la notazione è <code>&ne;</code>, in JavaScript viene scritto come un'assegnazione ma con un punto esclamativo davanti: <code>a != b</code>.
+=======
+We know many comparison operators from maths:
+
+- Greater/less than: <code>a &gt; b</code>, <code>a &lt; b</code>.
+- Greater/less than or equals: <code>a &gt;= b</code>, <code>a &lt;= b</code>.
+- Equals: `a == b` (please note the double equals sign `=`. A single symbol `a = b` would mean an assignment).
+- Not equals. In maths the notation is <code>&ne;</code>, but in JavaScript it's written as an assignment with an exclamation sign before it: <code>a != b</code>.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Il risultato è booleano
 
+<<<<<<< HEAD
 Come tutti gli altri operatori, quelli di confronto ritornano un valore. In questo caso il valore di ritorno è di tipo booleano.
 
 - `true` -- significa "si", "corretto" o "vero".
 - `false` -- significa "no", "sbagliato" o "falso".
+=======
+Like all other operators, a comparison returns a value. In this case, the value is a boolean.
+
+- `true` -- means "yes", "correct" or "the truth".
+- `false` -- means "no", "wrong" or "not the truth".
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -31,7 +47,11 @@ alert( result ); // true
 
 ## Confronto di stringhe
 
+<<<<<<< HEAD
 Per vedere quale stringa è più lunga di un'altra, viene utilizzato l'ordine "dizionario" o meglio "lessico-grafico".
+=======
+To see whether a string is greater than another, JavaScript uses the so-called "dictionary" or "lexicographical" order.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 In altre parole, le stringhe vengono confrontate lettera a lettera.
 
@@ -45,6 +65,7 @@ alert( 'Bee' > 'Be' ); // true
 
 L'algoritmo per confrontare due stringhe è semplice:
 
+<<<<<<< HEAD
 1. Confronta i primi caratteri di entrambe le stringhe.
 2. Se il primo è maggiore(o minore), allora la prima stringa è maggiore(o minore) della seconda. Abbiamo quindi finito.
 3. Altrimenti se i primi caratteri sono uguali, vengono comparati i secondi, nella stessa maniera.
@@ -54,20 +75,40 @@ L'algoritmo per confrontare due stringhe è semplice:
 Nell'esempio sopra, il confronto `'Z' > 'A'` ritorna il risultato al primo passo dell'algoritmo.
 
 Le stringhe `"Glow"` e `"Glee"` vengono confrontate carattere per carattere:
+=======
+1. Compare the first character of both strings.
+2. If the first character from the first string is greater (or less) than the other string's, then the first string is greater (or less) than the second. We're done.
+3. Otherwise, if both strings' first characters are the same, compare the second characters the same way.
+4. Repeat until the end of either string.
+5. If both strings end at the same length, then they are equal. Otherwise, the longer string is greater.
+
+In the examples above, the comparison `'Z' > 'A'` gets to a result at the first step while the strings `"Glow"` and `"Glee"` are compared character-by-character:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 1. `G` è uguale a `G`.
 2. `l` è uguale a `l`.
 3. `o` è maggiore di `e`. Qui si ferma. La prima stringa è maggiore.
 
+<<<<<<< HEAD
 ```smart header="Non un vero dizionario, ma un ordine Unicode"
 L'algoritmo di confronto esaminato sopra è molto simile a quello utilizzato nei dizionari cartacei o nelle agende telefoniche. Ma non è proprio uguale.
 
 Ad esempio, le lettere maiuscole contano. Una lettera maiuscola `"A"` non è uguale alla stessa minuscola `"a"`. Qual'è più grande? In realtà, quella minuscola. Come mai? Perchè le lettere minuscole hanno un indice di encoding maggiore nella tabella(Unicode). Ritorneremo nei dettagli specifici e alle conseguenze che porta nel capitolo <info:string>.
+=======
+```smart header="Not a real dictionary, but Unicode order"
+The comparison algorithm given above is roughly equivalent to the one used in dictionaries or phone books, but it's not exactly the same.
+
+For instance, case matters. A capital letter `"A"` is not equal to the lowercase `"a"`. Which one is greater? The lowercase `"a"`. Why? Because the lowercase character has a greater index in the internal encoding table JavaScript uses (Unicode). We'll get back to specific details and consequences of this in the chapter <info:string>.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ```
 
 ## Confronti tra tipi diversi
 
+<<<<<<< HEAD
 Quando compariamo valori che appartengono a tipi differenti, questi vengono convertiti in numeri.
+=======
+When comparing values of different types, JavaScript converts the values to numbers.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -76,7 +117,13 @@ alert( '2' > 1 ); // true, string '2' becomes a number 2
 alert( '01' == 1 ); // true, string '01' becomes a number 1
 ```
 
+<<<<<<< HEAD
 Per i valori booleani, `true` diventa `1` e `false` diventa `0`, quindi:
+=======
+For boolean values, `true` becomes `1` and `false` becomes `0`. 
+
+For example:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 alert( true == 1 ); // true
@@ -101,24 +148,40 @@ alert( Boolean(b) ); // true
 alert(a == b); // true!
 ```
 
+<<<<<<< HEAD
 Dal punto di vista di JavaScript questo è abbastanza normale. Un controllo di uguaglianza converte sempre utilizzando la conversione numerica (quindi `"0"` diventa `0`), mentre la conversione `Boolean` utilizza altre regole.
+=======
+From JavaScript's standpoint, this result is quite normal. An equality check converts values using the numeric conversion (hence `"0"` becomes `0`), while the explicit `Boolean` conversion uses another set of rules.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ````
 
 ## Uguaglianza stretta
 
+<<<<<<< HEAD
 Un controllo di uguaglianza standard `==` ha dei problemi. Non distingue tra `0` e `false`:
+=======
+A regular equality check `==` has a problem. It cannot differentiate `0` from `false`:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 alert( 0 == false ); // true
 ```
 
+<<<<<<< HEAD
 La stessa cosa accade con una stringa vuota:
+=======
+The same thing happens with an empty string:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 alert( '' == false ); // true
 ```
 
+<<<<<<< HEAD
 Questo perchè operandi di diversi tipi vengono convertiti a numeri dall'operatore di uguaglianza `==`. Una stringa vuota, come `false`, diventa zero.
+=======
+This happens because operands of different types are converted to numbers by the equality operator `==`. An empty string, just like `false`, becomes a zero.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Come possiamo fare se vogliamo distinguere tra `0` e `false`?
 
@@ -132,18 +195,32 @@ Proviamolo:
 alert( 0 === false ); // false, because the types are different
 ```
 
+<<<<<<< HEAD
 Esiste anche un operatore di "disuguaglianza stretta" `!==`, come analogo per l'operatore `!=`.
 
 L'operatore di uguaglianza stretta è un pò più lungo da scrivere, ma rende ovvio il controllo e lascia meno spazio ad errori.
+=======
+There is also a "strict non-equality" operator `!==` analogous to `!=`.
+
+The strict equality operator is a bit longer to write, but makes it obvious what's going on and leaves less room for errors.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Confronto con null e undefined
 
 Diamo un'occhiata ad ulteriori casi limite.
 
+<<<<<<< HEAD
 C'è un comportamento non atteso quando `null` o `undefined` vengono comparati con gli altri valori.
 
 Per un controllo di uguaglianza stretta `===`
 : Questi valori sono diversi, perchè ognuno di loro appartiene ad un tipo a se stante.
+=======
+There's a non-intuitive behavior when `null` or `undefined` are compared to other values.
+
+
+For a strict equality check `===`
+: These values are different, because each of them is a different type.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
     ```js run
     alert( null === undefined ); // false
@@ -156,10 +233,17 @@ Per un controllo non stretto `==`
     alert( null == undefined ); // true
     ```
 
+<<<<<<< HEAD
 Per confronti matematici `< > <= >=`
 : I valori `null/undefined` vengono convertiti in numeri: `null` diventa `0`, mentre `undefined` diventa `NaN`.
 
 Adesso notiamo una cosa divertente quando proviamo ad applicare queste regole. E, cosa più importante, come non cadere in tranelli a causa di queste caratteristiche.
+=======
+For maths and other comparisons `< > <= >=`
+: `null/undefined` are converted to numbers: `null` becomes `0`, while `undefined` becomes `NaN`.
+
+Now let's see some funny things that happen when we apply these rules. And, what's more important, how to not fall into a trap with them.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ### Un risultato strano: null vs 0
 
@@ -171,15 +255,25 @@ alert( null == 0 ); // (2) false
 alert( null >= 0 ); // (3) *!*true*/!*
 ```
 
+<<<<<<< HEAD
 Si, matematicamente può sembrare strano. L'ultimo risultato dice che "`null` è maggiore o uguale a zero". Quindi uno dei confronti sopra dovrebbe essere corretto, ma risultano entrambi falsi.
 
 La ragione è che il controllo di uguaglianza `==` e di confronto `> < >= <=` lavorano diversamente. Il confronto converte `null` ad un numero, quindi lo tratta come `0`. Questo è perchè (3) `null >= 0` è vero e (1) `null > 0` è falso.
+=======
+Mathematically, that's strange. The last result states that "`null` is greater than or equal to zero", so in one of the comparisons above it must be `true`, but they are both false.
+
+The reason is that an equality check `==` and comparisons `> < >= <=` work differently. Comparisons convert `null` to a number, treating it as `0`. That's why (3) `null >= 0` is true and (1) `null > 0` is false.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 D'altra parte, il controllo di uguaglianza `==` per `undefined` e `null` viene definito, senza alcuna conversione, loro sono uguali l'un l'altro ma non sono uguali a nient'altro. Questo è il motivo per cui (2) `null == 0` è falsa.
 
 ### Undefined è incomparabile
 
+<<<<<<< HEAD
 Il valore `undefined` non passa il confronto con nulla:
+=======
+The value `undefined` shouldn't be compared to other values:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 alert( undefined > 0 ); // false (1)
@@ -187,25 +281,50 @@ alert( undefined < 0 ); // false (2)
 alert( undefined == 0 ); // false (3)
 ```
 
+<<<<<<< HEAD
 Perchè non va bene neanche uno zero? Sempre falso!
 
 Noi abbiamo questi risultati perchè:
 
 - Il confronto `(1)` e `(2)` ritorna `false` perchè `undefined` viene convertito a `NaN`. Mentre `NaN` è un valore numerico speciale che ritorna `false` con tutti i confronti.
 - Il confronto di uguaglianza `(3)` ritorna `false`, perchè `undefined` è uguale solo a `null` e a nessun altro  valore.
+=======
+Why does it dislike zero so much? Always false!
+
+We get these results because:
+
+- Comparisons `(1)` and `(2)` return `false` because `undefined` gets converted to `NaN` and `NaN` is a special numeric value which returns `false` for all comparisons.
+- The equality check `(3)` returns `false` because `undefined` only equals `null` and no other value.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ### Eludere i problemi
 
+<<<<<<< HEAD
 Perchè abbiamo studiato questi esempi? Dovremmo ricordarci queste caratteristiche a memoria? Bhe, in realtà no. Questo tipo di trucchetti diventeranno familiari poco alla volta, ma c'è un modo sicure per eludere i problemi che possono sorgere.
+=======
+Why did we go over these examples? Should we remember these peculiarities all the time? Well, not really. Actually, these tricky things will gradually become familiar over time, but there's a solid way to evade problems with them:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Semplicemente tratte tutti i confronti con `undefined/null` solo con l'operatore di uguaglianza stretta `===`.
 
+<<<<<<< HEAD
 Non utilizzate i confronti `>= > < <=` con una variabile che potrebbe valere `null/undefined`, senza essere davvero sicuri di cosa state facendo. Se una variabile può avere questi tipi di valore, è buona norma eseguire un controllo separatamente.
+=======
+Don't use comparisons `>= > < <=` with a variable which may be `null/undefined`, unless you're really sure of what you're doing. If a variable can have these values, check for them separately.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Riepilogo
 
+<<<<<<< HEAD
 - Gli operatori di confronto ritornano un valore booleano.
 - Le stringhe vengono confrontate lettera per lettera seguendo l'ordine "lessico-grafico".
 - Quando valori di tipi differenti vengono confrontati, questi vengono converiti a numeri (con eccezione per il controllo di uguaglianza stretto).
 - I valori `null` e `undefined` sono `==` solo l'uno per l'altro e a nessun altro valore.
 - Va prestata attenzione quando si utilizzano gli operatori di confronto come `>` o `<` con variabili che potrebbero contenere `null/undefined`. Una buona idea è eseguire un controllo separato per `null/undefined`.
+=======
+- Comparison operators return a boolean value.
+- Strings are compared letter-by-letter in the "dictionary" order.
+- When values of different types are compared, they get converted to numbers (with the exclusion of a strict equality check).
+- The values `null` and `undefined` equal `==` each other and do not equal any other value.
+- Be careful when using comparisons like `>` or `<` with variables that can occasionally be `null/undefined`. Checking for `null/undefined` separately is a good idea.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/02-first-steps/09-alert-prompt-confirm/article.md b/1-js/02-first-steps/09-alert-prompt-confirm/article.md
index ec2615e98..08e7b3703 100644
--- a/1-js/02-first-steps/09-alert-prompt-confirm/article.md
+++ b/1-js/02-first-steps/09-alert-prompt-confirm/article.md
@@ -2,7 +2,11 @@
 
 Questa parte del tutorial ha l'intenzione di coprire JavaScript cosi per "com'è", senza i ritocchi specifici di ogni ambiente.
 
+<<<<<<< HEAD
 Ma continueremo comunque ad utilizzare un browser come ambiente di test. Quindi dovremmo conoscere almeno un paio di funzioni dell'interfaccia utente. In questo capitolo prenderemo familiarità con le funzioni browser `alert`, `prompt` e `confirm`.
+=======
+But we'll still be using the browser as our demo environment, so we should know at least a few of its user-interface functions. In this chapter, we'll get familiar with the browser functions `alert`, `prompt` and `confirm`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## alert
 
@@ -12,7 +16,11 @@ Sintassi:
 alert(message);
 ```
 
+<<<<<<< HEAD
 Questo mostra un messaggio e mette in pausa l'esecuzione dello script finchè l'utente non preme il pulsante "OK".
+=======
+This shows a message and pauses script execution until the user presses "OK".
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -20,27 +28,48 @@ Ad esempio:
 alert("Hello");
 ```
 
+<<<<<<< HEAD
 La finestra che appare con il messaggio si chiama *modal window*. La parola "modal" significa che l'utente non potrà interagire con il resto della pagina, premere altri bottoni etc, fino a che non avrà interagito con la finestra. In questo esempio -- quando premerà "OK".
 
 ## prompt
 
 La funzione `prompt` accetta due argomenti:
+=======
+The mini-window with the message is called a *modal window*. The word "modal" means that the visitor can't interact with the rest of the page, press other buttons, etc. until they have dealt with the window. In this case -- until they press "OK".
+
+## prompt
+
+The function `prompt` accepts two arguments:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js no-beautify
-result = prompt(title[, default]);
+result = prompt(title, [default]);
 ```
 
+<<<<<<< HEAD
 Questo mostrerà una modal window con un messaggio testuale, un campo di input per l'utente ed il bottone OK/CANCEL.
 
 `title`
 : Il testo da mostrare all'utente.
+=======
+It shows a modal window with a text message, an input field for the visitor, and the buttons OK/CANCEL.
+
+`title`
+: The text to show the visitor.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 `default`
 : Un secondo parametro opzionale, che rappresenta il valore iniziale del campo input.
 
+<<<<<<< HEAD
 L'utente potrà scrivere nel campo input del prompt e successivamente premere OK. O in alternativa possono cancellare l'input premendo su CANCEL o la combinazione di tasti `key:Esc`.
 
 La chiamata ad un `prompt` ritorna il testo del campo input o `null` se è stato premuto cancel.
+=======
+The visitor may type something in the prompt input field and press OK. Or they can cancel the input by pressing CANCEL or hitting the `key:Esc` key.
+
+The call to `prompt` returns the text from the input field or `null` if the input was canceled.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -50,16 +79,27 @@ let age = prompt('How old are you?', 100);
 alert(`You are ${age} years old!`); // You are 100 years old!
 ```
 
+<<<<<<< HEAD
 ````warn header="IE: inserisce sempre un valore `default`"
 Il secondo parametro è opzionale. Ma se non inseriamo niente, Internet Explorer inserirà il testo `"undefined"` nel prompt.
 
 Provate ad eseguire il seguente codice su Internet Explorer:
+=======
+````warn header="In IE: always supply a `default`"
+The second parameter is optional, but if we don't supply it, Internet Explorer will insert the text `"undefined"` into the prompt.
+
+Run this code in Internet Explorer to see:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let test = prompt("Test");
 ```
 
+<<<<<<< HEAD
 Quindi, per farlo funzionare ugualmente su IE, è consigliato fornire sempre il secondo argomento:
+=======
+So, for prompts to look good in IE, we recommend always providing the second argument:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let test = prompt("Test", ''); // <-- for IE
@@ -74,7 +114,11 @@ La sintassi:
 result = confirm(question);
 ```
 
+<<<<<<< HEAD
 La funzione `confirm` mostra una modal window con un `domanda` e due bottoni: OK e CANCEL.
+=======
+The function `confirm` shows a modal window with a `question` and two buttons: OK and CANCEL.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Il risultato è `true` se viene premuto OK altrimenti è `false`.
 
@@ -88,22 +132,39 @@ alert( isBoss ); // true if OK is pressed
 
 ## Riepilogo
 
+<<<<<<< HEAD
 Abbiamo osservato 3 funzioni specifiche dei browser per interagire con l'utente:
+=======
+We covered 3 browser-specific functions to interact with visitors:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 `alert`
 : mostra un messaggio.
 
 `prompt`
+<<<<<<< HEAD
 : mostra un messaggio chiedendo all'utente un input testuale. Ritorna il testo o, se viene premuto CANCEL o il tasto `key:Esc`, tutti i browser ritornano `null`.
+=======
+: shows a message asking the user to input text. It returns the text or, if CANCEL or `key:Esc` is clicked, `null`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 `confirm`
 : mostra un messaggio e aspetta che l'utente prema "OK" o "CANCEL". Ritorna `true` se viene premuto OK e `false` per CANCEL/`key:Esc`.
 
+<<<<<<< HEAD
 Tutti questi metodi sono dei modal window: quindi interrompono l'esecuzione dello script e non consentono all'utente di interagire con il resto della pagina finchè il messaggio non viene rimosso:
+=======
+All these methods are modal: they pause script execution and don't allow the visitor to interact with the rest of the page until the window has been dismissed.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ci sono due limitazioni che sono condivise da tutti i metodi visti sopra:
 
+<<<<<<< HEAD
 1. La posizione esatta della modal window viene decisa dal browser. Solitamente sta al centro.
 2. Anche la grafica della modal window dipende dal browser. Non possiamo modificarla.
+=======
+1. The exact location of the modal window is determined by the browser. Usually, it's in the center.
+2. The exact look of the window also depends on the browser. We can't modify it.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Questo è il prezzo da pagare per la semplicità. Ci sono altri modi di mostrare finestre carine, ricche di informazioni e interazioni con l'utente, ma se non ci interessa fare grandi cose, questi metodi possono essere utili.
diff --git a/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2.png b/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2.png
index 8c57b1885..04fb1fb0b 100644
Binary files a/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2.png and b/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2.png differ
diff --git a/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2@2x.png b/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2@2x.png
index cbb2c611a..08226b790 100644
Binary files a/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2@2x.png and b/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2@2x.png differ
diff --git a/1-js/02-first-steps/10-ifelse/4-check-login/ifelse_task.png b/1-js/02-first-steps/10-ifelse/4-check-login/ifelse_task.png
deleted file mode 100644
index 8b54dc83d..000000000
Binary files a/1-js/02-first-steps/10-ifelse/4-check-login/ifelse_task.png and /dev/null differ
diff --git a/1-js/02-first-steps/10-ifelse/4-check-login/ifelse_task@2x.png b/1-js/02-first-steps/10-ifelse/4-check-login/ifelse_task@2x.png
deleted file mode 100644
index 92001dfe8..000000000
Binary files a/1-js/02-first-steps/10-ifelse/4-check-login/ifelse_task@2x.png and /dev/null differ
diff --git a/1-js/02-first-steps/10-ifelse/article.md b/1-js/02-first-steps/10-ifelse/article.md
index f471c832c..dcbd86476 100644
--- a/1-js/02-first-steps/10-ifelse/article.md
+++ b/1-js/02-first-steps/10-ifelse/article.md
@@ -1,12 +1,22 @@
 # Operatori condizionali: if, '?'
 
+<<<<<<< HEAD
 Qualche volta abbiamo bisogno di eseguire certe azioni solo nel caso valgano determinate condizioni.
 
 Per questo c'è l'istruzione `if` e anche l'operatore condizionale di valutazione (ternario) a cui noi ci riferiremo con l'operatore "punto di domanda" `?` per semplicità.
+=======
+Sometimes, we need to perform different actions based on different conditions.
+
+To do that, we use the `if` statement and the conditional (ternary) operator which we will be referring to as the “question mark” operator `?` for simplicity.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## L'istruzione "if" 
 
+<<<<<<< HEAD
 L'istruzione `if` richiede una condizione, la valuta, e se il risultato è `true`, esegue il codice.
+=======
+The `if` statement evaluates a condition and, if the condition's result is `true`, executes a block of code.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -18,9 +28,15 @@ if (year == 2015) alert( 'You are right!' );
 */!*
 ```
 
+<<<<<<< HEAD
 Nell'esempio sopra, la condizione è un semplice controllo di uguaglianza: `year == 2015`, ma potrebbe essere qualcosa di molto più complesso.
 
 Se dobbiamo eseguire più di un'istruzione, queste vanno raggruppate tramite le parentesi graffe:
+=======
+In the example above, the condition is a simple equality check (`year == 2015`), but it can be much more complex.
+
+If we want to execute more than one statement, we have to wrap our code block inside curly braces:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 if (year == 2015) {
@@ -29,16 +45,29 @@ if (year == 2015) {
 }
 ```
 
+<<<<<<< HEAD
 E' consigliabile raggruppare sempre il codice all'interno delle parentesi graffe `{}` quando si usa un `if`, anche se contiene una sola istruzione. La leggibilità viene migliorata.
+=======
+We recommend wrapping your code block with curly braces `{}` every time you use an `if` statement, even if there is only one statement to execute. Doing so improves readability.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Conversione booleana
 
+<<<<<<< HEAD
 L'istruzione `if (…)` valuta la condizione tra le parentesi e la converte al tipo booleano.
+=======
+The `if (…)` statement evaluates the expression in its parentheses and converts the result to a boolean.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ricordiamo le regole di conversione viste nel capitolo <info:type-conversions>:
 
+<<<<<<< HEAD
 - Il numero `0`, una stringa vuota `""`, `null`, `undefined` e `NaN` diventano `false`. Per questo vengono chiamati valori "falsi".
 - Gli altri valori diventano `true`, quindi vengono chiamati "veri".
+=======
+- A number `0`, an empty string `""`, `null`, `undefined`, and `NaN` all become `false`. Because of that they are called "falsy" values.
+- Other values become `true`, so they are called "truthy".
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Quindi, il codice nell'esempio qui sotto, non verrà mai eseguito:
 
@@ -48,7 +77,11 @@ if (0) { // 0 is falsy
 }
 ```
 
+<<<<<<< HEAD
 ...Invece nel prossimo esempio -- verrà eseguito sempre:
+=======
+...and inside this condition -- it always will:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 if (1) { // 1 is truthy
@@ -56,7 +89,11 @@ if (1) { // 1 is truthy
 }
 ```
 
+<<<<<<< HEAD
 Possiamo anche passare un valore booleano già valutato, come qui:
+=======
+We can also pass a pre-evaluated boolean value to `if`, like this:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 let cond = (year == 2015); // equality evaluates to true or false
@@ -68,11 +105,15 @@ if (cond) {
 
 ## La clausola "else" 
 
+<<<<<<< HEAD
 L'istruzione `if` può essere seguita da un blocco opzionale "else". Questo viene eseguito quando la condizione è falsa.
+=======
+The `if` statement may contain an optional "else" block. It executes when the condition is false.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 ```js run
-let year = prompt('In which year was ECMAScript-2015 specification published?', '');
+let year = prompt('In which year was the ECMAScript-2015 specification published?', '');
 
 if (year == 2015) {
   alert( 'You guessed it right!' );
@@ -83,12 +124,16 @@ if (year == 2015) {
 
 ## Condizione multiple: "else if"
 
+<<<<<<< HEAD
 Qualche volta vorremmo testare diverse varianti di una condizione. Per questo esiste la clausola `else if`.
+=======
+Sometimes, we'd like to test several variants of a condition. The `else if` clause lets us do that.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
 ```js run
-let year = prompt('In which year was ECMAScript-2015 specification published?', '');
+let year = prompt('In which year was the ECMAScript-2015 specification published?', '');
 
 if (year < 2015) {
   alert( 'Too early...' );
@@ -99,13 +144,23 @@ if (year < 2015) {
 }
 ```
 
+<<<<<<< HEAD
 Nel codice sopra JavaScript controlla prima `year < 2015`. Se risulta falso allora va alla successiva condizione `year > 2015`, altrimenti mostra il blocco else con l'`alert`.
 
 Ci possono essere molti blocchi `else if`. L'`else` finale è opzionale.
+=======
+In the code above, JavaScript first checks `year < 2015`. If that is falsy, it goes to the next condition `year > 2015`. If that is also falsy, it shows the last `alert`.
+
+There can be more `else if` blocks. The final `else` is optional.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Operatore Ternario '?'
 
+<<<<<<< HEAD
 Qualche volta abbiamo bisogno di assegnare un valore ad una variabile in base ad una condizione.
+=======
+Sometimes, we need to assign a variable depending on a condition.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -124,16 +179,24 @@ if (age > 18) {
 alert(accessAllowed);
 ```
 
+<<<<<<< HEAD
 Esiste un'operatore "ternario" o "punto interrogativo" che ci consente di farlo in maniera più breve e semplice.
+=======
+The so-called "ternary" or "question mark" operator lets us do that in a shorter and simpler way.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 L'operatore viene rappresentato dal punto interrogativo `?`.  Il termine formale è "ternario", il che significa che richiede tre operatori. E' l'unico operatore in JavaScript di questo tipo.
 
 La sintassi è:
 ```js
-let result = condition ? value1 : value2
+let result = condition ? value1 : value2;
 ```
 
+<<<<<<< HEAD
 La `condition` viene valutata, se risulta viene ritornato il `value1`, altrimenti viene ritornato il -- `value2`.
+=======
+The `condition` is evaluated: if it's truthy then `value1` is returned, otherwise -- `value2`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -141,7 +204,13 @@ Ad esempio:
 let accessAllowed = (age > 18) ? true : false;
 ```
 
+<<<<<<< HEAD
 Tecnicamente, potremmo omettere le parentesi su `age > 18`. L'operatore ternario ha una precedenza molto bassa. Viene eseguito dopo gli operatori di confronto `>`, quindi il risultato sarebbe lo stesso:
+=======
+Technically, we can omit the parentheses around `age > 18`. The question mark operator has a low precedence, so it executes after the comparison `>`. 
+
+This example will do the same thing as the previous one:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 // the comparison operator "age > 18" executes first anyway
@@ -149,10 +218,17 @@ Tecnicamente, potremmo omettere le parentesi su `age > 18`. L'operatore ternario
 let accessAllowed = age > 18 ? true : false;
 ```
 
+<<<<<<< HEAD
 Le parentesi rendono però il codice più leggibile, quindi è consigliabile utilizzarle.
 
 ````smart
 Nell'esempio sopra sarebbe possibile evitare l'operatore ternario, perchè l'operatore di confronto ritorna già di suo `true/false`:
+=======
+But parentheses make the code more readable, so we recommend using them.
+
+````smart
+In the example above, you can avoid using the question mark operator because the comparison itself returns `true/false`:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 // the same
@@ -162,7 +238,11 @@ let accessAllowed = age > 18;
 
 ## Operatori '?' multipli
 
+<<<<<<< HEAD
 Una sequenza di operatori `?` consente di ritornare un valore che dipende da più condizioni.
+=======
+A sequence of question mark operators `?` can return a value that depends on more than one condition.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 ```js run
@@ -176,6 +256,7 @@ let message = (age < 3) ? 'Hi, baby!' :
 alert( message );
 ```
 
+<<<<<<< HEAD
 Potrebbe essere difficile inizialmente capirne la logica. Ma dopo averlo guardato da più vicino ci accorgiamo è una semplice sequenza di condizioni.
 
 1. Il primo operatore "?" controlla `age < 3`.
@@ -184,6 +265,16 @@ Potrebbe essere difficile inizialmente capirne la logica. Ma dopo averlo guardat
 4. Se questo è vero -- ritorna `'Greetings!'`, altrimenti -- segue la colonna `":"` e ritorna `'What an unusual age!'`.
 
 La stessa logica viene usata con `if..else`:
+=======
+It may be difficult at first to grasp what's going on. But after a closer look, we can see that it's just an ordinary sequence of tests:
+
+1. The first question mark checks whether `age < 3`.
+2. If true -- it returns `'Hi, baby!'`. Otherwise, it continues to the expression after the colon '":"', checking `age < 18`.
+3. If that's true -- it returns `'Hello!'`. Otherwise, it continues to the expression after the next colon '":"', checking `age < 100`.
+4. If that's true -- it returns `'Greetings!'`. Otherwise, it continues to the expression after the last colon '":"', returning `'What an unusual age!'`.
+
+Here's how this looks using `if..else`:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 if (age < 3) {
@@ -210,6 +301,7 @@ let company = prompt('Which company created JavaScript?', '');
 */!*
 ```
 
+<<<<<<< HEAD
 In base al risultato della condizione `company == 'Netscape'`, viene eseguita la prima o la seconda parte, e mostra il giusto alert.
 
 Qui non assegnamo il risultato ad una variabile. L'idea è di eseguire codice differente in base alla condizione.
@@ -219,6 +311,17 @@ Qui non assegnamo il risultato ad una variabile. L'idea è di eseguire codice di
 La notazione risulta essere molto più breve rispetto all'istruzione `if`, questo viene sfruttato da molti programmatori. Ma risulta meno leggibile.
 
 Lo stesso codice realizzato con un istruzione `if`:
+=======
+Depending on the condition `company == 'Netscape'`, either the first or the second expression after the `?` gets executed and shows an alert.
+
+We don't assign a result to a variable here. Instead, we execute different code depending on the condition.
+
+**We don't recommend using the question mark operator in this way.**
+
+The notation is shorter than the equivalent `if` statement, which appeals to some programmers. But it is less readable.
+
+Here is the same code using `if` for comparison:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run no-beautify
 let company = prompt('Which company created JavaScript?', '');
@@ -232,6 +335,12 @@ if (company == 'Netscape') {
 */!*
 ```
 
+<<<<<<< HEAD
 I nostri occhi scannerizzano il codice verticalmente. Quindi i costrutti che si estendono per qualche riga risultano più semplici da capire piuttosto di un'unica istruzione che si estende orrizontalmente.
 
 L'idea dell'operatore ternario `?` è di ritornare un valore piuttosto che un altro, in base al valore di una condizione. Va quindi utilizzato solo per questo tipo di situazioni. Invece per eseguire diversi codice è consigliabile utilizzare il costrutto `if`.
+=======
+Our eyes scan the code vertically. Code blocks which span several lines are easier to understand than a long, horizontal instruction set.
+
+The purpose of the question mark operator `?` is to return one value or another depending on its condition. Please use it for exactly that. Use `if` when you need to execute different branches of code.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/ifelse_task.png b/1-js/02-first-steps/11-logical-operators/9-check-login/ifelse_task.png
new file mode 100644
index 000000000..32f0d4b94
Binary files /dev/null and b/1-js/02-first-steps/11-logical-operators/9-check-login/ifelse_task.png differ
diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/ifelse_task@2x.png b/1-js/02-first-steps/11-logical-operators/9-check-login/ifelse_task@2x.png
new file mode 100644
index 000000000..c3867e62c
Binary files /dev/null and b/1-js/02-first-steps/11-logical-operators/9-check-login/ifelse_task@2x.png differ
diff --git a/1-js/02-first-steps/10-ifelse/4-check-login/solution.md b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
similarity index 100%
rename from 1-js/02-first-steps/10-ifelse/4-check-login/solution.md
rename to 1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
diff --git a/1-js/02-first-steps/10-ifelse/4-check-login/task.md b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
similarity index 72%
rename from 1-js/02-first-steps/10-ifelse/4-check-login/task.md
rename to 1-js/02-first-steps/11-logical-operators/9-check-login/task.md
index e74a3c47b..aa377ce19 100644
--- a/1-js/02-first-steps/10-ifelse/4-check-login/task.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
@@ -20,6 +20,10 @@ Lo schema:
 
 Utilizzate blocchi `if` annidati. Tenete a mente anche la leggibilità del codice.
 
+<<<<<<< HEAD:1-js/02-first-steps/10-ifelse/4-check-login/task.md
 Suggerimento: passare un input vuoto tramite prompr ritorna una stringa vuota `''`. Premere `key:ESC` con prompt aperto ritorna `null`.
+=======
+Hint:  passing an empty input to a prompt returns an empty string `''`. Pressing `key:ESC` during a prompt returns `null`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb:1-js/02-first-steps/11-logical-operators/9-check-login/task.md
 
 [demo]
diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index f1ed03e8a..2c4953148 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -2,7 +2,11 @@
 
 In JavaScript ci sono tre operatori logici: `||` (OR), `&&` (AND), `!` (NOT).
 
+<<<<<<< HEAD
 Nonostante si chiamino "logici", possono essere applicati a valori di qualsiasi tipo, non solo ai booleani. Il risultato stesso può essere di qualunque tipo.
+=======
+Although they are called "logical", they can be applied to values of any type, not only boolean. Their result can also be of any type.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Vediamoli nei dettagli.
 
@@ -14,9 +18,15 @@ L'operatore "OR" viene rappresentato da due linee verticali:
 result = a || b;
 ```
 
+<<<<<<< HEAD
 Nella programmazione classica, l'OR logico è pensato per manipolare solo tipi booleani. Se almeno un argomento è `true`, allora il risultato sarà `true`, altrimenti sarà `false`.
 
 In JavaScript questo operatore è un pò più potente. Ma prima guardiamo come si comporta con valori booleani.
+=======
+In classical programming, the logical OR is meant to manipulate boolean values only. If any of its arguments are `true`, it returns `true`, otherwise it returns `false`.
+
+In JavaScript, the operator is a little bit trickier and more powerful. But first, let's see what happens with boolean values.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ci sono quattro combinazioni logiche possibili:
 
@@ -29,9 +39,15 @@ alert( false || false ); // false
 
 Come possiamo vedere, il risultato è sempre `true` tranne nei casi in cui entrambi gli operandi sono `false`.
 
+<<<<<<< HEAD
 Se un operando non è booleano, allora viene convertito in booleano per essere valutato.
 
 Ad esempio, il numero `1` viene visto come `true`, il numero `0` -- come `false`:
+=======
+If an operand is not a boolean, it's converted to a boolean for the evaluation.
+
+For instance, the number `1` is treated as `true`, the number `0` as `false`:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 if (1 || 0) { // works just like if( true || false )
@@ -39,7 +55,11 @@ if (1 || 0) { // works just like if( true || false )
 }
 ```
 
+<<<<<<< HEAD
 La maggior parte delle volte, OR `||` viene utilizzato in un `if` per verificare se *almeno una* delle condizioni è vera.
+=======
+Most of the time, OR `||` is used in an `if` statement to test if *any* of the given conditions is `true`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -64,9 +84,15 @@ if (hour < 10 || hour > 18 || isWeekend) {
 }
 ```
 
+<<<<<<< HEAD
 ## OR preleva il primo valore vero
 
 La logica descritta sopra è ovvia. Adesso proviamo ad addentrarci in qualche caratteristica "extra" di JavaScript.
+=======
+## OR finds the first truthy value
+
+The logic described above is somewhat classical. Now, let's bring in the "extra" features of JavaScript.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Si può estendere l'algoritmo come segue:
 
@@ -78,9 +104,15 @@ result = value1 || value2 || value3;
 
 L'operatore OR `||` si comporta come segue:
 
+<<<<<<< HEAD
 - Valuta gli operandi da sinistra a destra.
 - Ogni operando viene converito in booleano. Se il risultato è `true`, allora si ferma e ritorna il valore originale dell'operando.
 - Se tutti gli altri operandi sono stati valutati (ad esempio tutti erano `false`), ritorna l'ultimo operando.
+=======
+- Evaluates operands from left to right.
+- For each operand, converts it to boolean. If the result is `true`, stops and returns the original value of that operand.
+- If all operands have been evaluated (i.e. all were `false`), returns the last operand.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Un valore viene ritornato nella sua forma originale, non nella sua conversione booleana.
 
@@ -97,6 +129,7 @@ alert( null || 0 || 1 ); // 1 (the first truthy value)
 alert( undefined || null || 0 ); // 0 (all falsy, returns the last value)
 ```
 
+<<<<<<< HEAD
 Questo ci porta ad alcuni utilizzi interessanti rispetto al "puro e classico OR booleano".boolean-only OR".
 
 1. **Prelevare il primo valore vero da una lista di variabili o espressioni.**
@@ -104,6 +137,15 @@ Questo ci porta ad alcuni utilizzi interessanti rispetto al "puro e classico OR
     Immaginiamo di avere diverse variabili, che possono contenere sia dati che `null/undefined`. Abbiamo bisogno di scegliere la prima che contiene dati.
 
     Possiamo utilizzare OR `||` per questo:
+=======
+This leads to some interesting usage compared to a "pure, classical, boolean-only OR".
+
+1. **Getting the first truthy value from a list of variables or expressions.**
+
+    Imagine we have several variables which can either contain data or be `null/undefined`. How can we find the first one with data?
+
+    We can use OR `||`:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
     ```js run
     let currentUser = null;
@@ -116,6 +158,7 @@ Questo ci porta ad alcuni utilizzi interessanti rispetto al "puro e classico OR
     alert( name ); // selects "John" – the first truthy value
     ```
 
+<<<<<<< HEAD
     Se entrambe `currentUser` e `defaultUser` sono false allora il risultato sarà `"unnamed"`.
 2. **Valutazione a Corto-Circuito.**
 
@@ -124,6 +167,16 @@ Questo ci porta ad alcuni utilizzi interessanti rispetto al "puro e classico OR
     Questo si vede chiaramente quando il secondo argomento causerebbe side-effect. Come l'assegnazione di una variabile.
 
     Se proviamo ad eseguire l'esempio che segue, `x` non verrà assegnata:
+=======
+    If both `currentUser` and `defaultUser` were falsy, `"unnamed"` would be the result.
+2. **Short-circuit evaluation.**
+
+    Operands can be not only values, but arbitrary expressions. OR evaluates and tests them from left to right. The evaluation stops when a truthy value is reached, and the value is returned. This process is called "a short-circuit evaluation" because it goes as short as possible from left to right.
+
+    This is clearly seen when the expression given as the second argument has a side effect like a variable assignment.
+
+    In the example below, `x` does not get assigned:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
     ```js run no-beautify
     let x;
@@ -133,7 +186,11 @@ Questo ci porta ad alcuni utilizzi interessanti rispetto al "puro e classico OR
     alert(x); // undefined, because (x = 1) not evaluated
     ```
 
+<<<<<<< HEAD
     ...Se il primo argomento è `false`, allora `OR` prosegue e valuta il secondo, in questo caso l'assegnazione funziona:
+=======
+    If, instead, the first argument is `false`, `||` evaluates the second one, thus running the assignment:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
     ```js run no-beautify
     let x;
@@ -143,11 +200,19 @@ Questo ci porta ad alcuni utilizzi interessanti rispetto al "puro e classico OR
     alert(x); // 1
     ```
 
+<<<<<<< HEAD
     Un assegnazione è un caso semplice, potrebbero essere coinvolti altri tipi di side-effect.
 
     Quello che abbiamo visto, è un "modo breve di fare `if`". Il primo operando viene convertito a booleano e solo se è falso viene eseguito il secondo.
 
     La maggior parte delle volte è meglio utilizzare un " `if` "regolare", per mantenere il codice leggibile, in alcuni casi però può risultare utile.
+=======
+    An assignment is a simple case. Other side effects can also be involved.
+
+    As we can see, such a use case is a "shorter way of doing `if`". The first operand is converted to boolean. If it's false, the second one is evaluated.
+
+    Most of time, it's better to use a "regular" `if` to keep the code easy to understand, but sometimes this can be handy.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## && (AND)
 
@@ -157,7 +222,11 @@ L'operatore AND viene rappresentato con `&&`:
 result = a && b;
 ```
 
+<<<<<<< HEAD
 Nella programmazione classica AND ritorna `true` se entrambri gli operandi sono veri, altrimenti ritorna `false`:
+=======
+In classical programming, AND returns `true` if both operands are truthy and `false` otherwise:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 alert( true && true );   // true
@@ -173,11 +242,15 @@ let hour = 12;
 let minute = 30;
 
 if (hour == 12 && minute == 30) {
-  alert( 'Time is 12:30' );
+  alert( 'The time is 12:30' );
 }
 ```
 
+<<<<<<< HEAD
 Proprio come per OR, qualsiasi valore è consentito come operando per AND:
+=======
+Just as with OR, any value is allowed as an operand of AND:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 if (1 && 0) { // evaluated as true && false
@@ -186,7 +259,11 @@ if (1 && 0) { // evaluated as true && false
 ```
 
 
+<<<<<<< HEAD
 ## AND cerca il primo valore falso
+=======
+## AND finds the first falsy value
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Fornire più valori AND:
 
@@ -196,9 +273,15 @@ result = value1 && value2 && value3;
 
 L'operatore AND `&&` si comporta come segue:
 
+<<<<<<< HEAD
 - Valuta gli operandi da sinistra a destra.
 - Ogni operando viene convertito in booleano. Se il risultato è `false`, si ferma e ritorna il valore originale dell'operando.
 - Se tutti gli operandi precedenti sono stati valutati (ad esempio nel caso siano tutti veri) , ritorna l'ultimo operando.
+=======
+- Evaluates operands from left to right.
+- For each operand, converts it to a boolean. If the result is `false`, stops and returns the original value of that operand.
+- If all operands have been evaluated (i.e. all were truthy), returns the last operand.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 In altre parole, AND ritorna il primo valore falso se lo trova, altrimenti ritorna l'ultimo valore.
 
@@ -233,7 +316,11 @@ alert( 1 && 2 && 3 ); // 3, the last one
 ````smart header="Precedenza di AND `&&` è maggiore dell'OR `||`"
 La precedenza dell'operatore AND`&&` è maggiore di quella dell'OR `||`.
 
+<<<<<<< HEAD
 Quindi il codice `a && b || c && d` è praticamente uguale all'espressione: `(a && b) || (c && d)`.
+=======
+So the code `a && b || c && d` is essentially the same as if the `&&` expressions were in parentheses: `(a && b) || (c && d)`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ````
 
 Proprio come l'OR, anche AND `&&` può qualche volta rimpiazzare `if`.
@@ -246,7 +333,11 @@ let x = 1;
 (x > 0) && alert( 'Greater than zero!' );
 ```
 
+<<<<<<< HEAD
 Le azione nella parte destra di `&&` vengono eseguite solamente se la valutazione non si ferma prima. Cioè: solo se `(x > 0)` è vera.
+=======
+The action in the right part of `&&` would execute only if the evaluation reaches it. That is, only if `(x > 0)` is true.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Quindi sostanzialmente è analogo a:
 
@@ -258,9 +349,15 @@ if (x > 0) {
 }
 ```
 
+<<<<<<< HEAD
 La variante con `&&` sembra essere più corta. Ma l'istruzione `if` è più ovvia e tende ad essere più leggibile.
 
 Quindi è consigliato usare ogni costrutto solo per i suoi scopi. Usate un `if` se volete imporre una condizione. Utilizzate invece `&&` se volete un AND.
+=======
+The variant with `&&` appears shorter. But `if` is more obvious and tends to be a little bit more readable.
+
+So we recommend using every construct for its purpose: use `if` if we want if and use `&&` if we want AND.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## ! (NOT)
 
@@ -274,8 +371,13 @@ result = !value;
 
 L'operatore accetta un solo argomento e si comporta come segue:
 
+<<<<<<< HEAD
 1. Converte l'operando al tipo booleano: `true/false`.
 2. Ritorna il valore inverso.
+=======
+1. Converts the operand to boolean type: `true/false`.
+2. Returns the inverse value.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -291,7 +393,11 @@ alert( !!"non-empty string" ); // true
 alert( !!null ); // false
 ```
 
+<<<<<<< HEAD
 Quello che accade è che il primo NOT converte il tipo a booleano e ritorna il suo inverso, il secondo NOT lo inverte nuovamente. Alla fine abbiamo un valore di tipo booleano.
+=======
+That is, the first NOT converts the value to boolean and returns the inverse, and the second NOT inverses it again. In the end, we have a plain value-to-boolean conversion.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 C'è un modo molto più lungo per fare la stessa cosa -- una funzione del linguaggio `Boolean`:
 
@@ -300,4 +406,8 @@ alert( Boolean("non-empty string") ); // true
 alert( Boolean(null) ); // false
 ```
 
+<<<<<<< HEAD
 La precedenza del NOT `!` è la più alta fra tutti gli operatori logici quindi viene sempre eseguita per prima, precede `&&`, `||`.
+=======
+The precedence of NOT `!` is the highest of all logical operators, so it always executes first, before `&&` or `||`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/02-first-steps/12-while-for/7-list-primes/solution.md b/1-js/02-first-steps/12-while-for/7-list-primes/solution.md
index 2fb8dcccc..39c30acc2 100644
--- a/1-js/02-first-steps/12-while-for/7-list-primes/solution.md
+++ b/1-js/02-first-steps/12-while-for/7-list-primes/solution.md
@@ -26,4 +26,8 @@ for (let i = 2; i <= n; i++) { // for each i...
 }
 ```
 
+<<<<<<< HEAD
 Ci sono molti modi per ottimizzarlo. Ad esempio, potremmo controllare i divisori di `2` fino alla radice di `i`. In ogni caso, se vogliamo essere veramete efficenti su grandi intervalli, abbiamo bisogno di cambiare approcio ed affidarci ad algoritmi matematici più avanzati e complessi, come [Quadratic sieve](https://en.wikipedia.org/wiki/Quadratic_sieve), [General number field sieve](https://en.wikipedia.org/wiki/General_number_field_sieve) etc.
+=======
+There's a lot of space to opimize it. For instance, we could look for the divisors from `2` to square root of `i`. But anyway, if we want to be really efficient for large intervals, we need to change the approach and rely on advanced maths and complex algorithms like [Quadratic sieve](https://en.wikipedia.org/wiki/Quadratic_sieve), [General number field sieve](https://en.wikipedia.org/wiki/General_number_field_sieve) etc.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/02-first-steps/12-while-for/article.md b/1-js/02-first-steps/12-while-for/article.md
index dda44463e..e7fc31581 100644
--- a/1-js/02-first-steps/12-while-for/article.md
+++ b/1-js/02-first-steps/12-while-for/article.md
@@ -1,10 +1,18 @@
 # Cicli: while e for
 
+<<<<<<< HEAD
 Abbiamo spesso bisogno di eseguire la stessa azione più volte di fila.
 
 Ad esempio, quando abbiamo bisogno di ritornare della merce da una lista una dopo l'altra. O anche solo eseguire lo stesso codice per ogni numero da 1 a 10.
 
 I *Cicli* sono un modo di ripetere la stessa parte di codice più volte.
+=======
+We often need to repeat actions.
+
+For example, outputting goods from a list one after another or just running the same code for each number from 1 to 10.
+
+*Loops* are a way to repeat the same code multiple times.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Il ciclo "while" 
 
@@ -31,11 +39,19 @@ while (i < 3) { // shows 0, then 1, then 2
 
 Una singola esecuzione del corpo del ciclo viene chiamata *un iterazione*. Il ciclo nell'esempio sopra fa tre iterazioni.
 
+<<<<<<< HEAD
 Se nell'esempio sopra non ci fosse `i++`, il ciclo si ripeterebbe per sempre (in teoria). Nella pratica, il browser ha dei metodi per bloccare questi cicli, con JavaScript server-side è necessario arrestare il processo.
 
 Qualsiasi espressione o variabile può essere utilizzata come condizione di un ciclo, non solo un confronto. Le espressioni vengono valutate e convertite al tipo bool dal ciclo `while`.
 
 Ad esempio, un modo più breve di scrivere `while (i != 0)` potrebbe essere `while (i)`:
+=======
+If `i++` was missing from the example above, the loop would repeat (in theory) forever. In practice, the browser provides ways to stop such loops, and in server-side JavaScript, we can kill the process.
+
+Any expression or variable can be a loop condition, not just comparisons: the condition is evaluated and converted to a boolean by `while`.
+
+For instance, a shorter way to write `while (i != 0)` is `while (i)`:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let i = 3;
@@ -68,7 +84,11 @@ do {
 } while (condition);
 ```
 
+<<<<<<< HEAD
 Il ciclo esegue prima il corpo, poi controlla la condizione, se questa è vera, esegue nuovamente il corpo.
+=======
+The loop will first execute the body, then check the condition, and, while it's truthy, execute it again and again.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -80,11 +100,19 @@ do {
 } while (i < 3);
 ```
 
+<<<<<<< HEAD
 Questa tipo di sintassi viene usata molto raramente ad eccezione dei casi in cui si vuole che il corpo del ciclo venga eseguito **almeno una volta** senza controllo sulla condizione. La forma più utilizzata è comunque: `while(…) {…}`.
+=======
+This form of syntax should only be used when you want the body of the loop to execute **at least once** regardless of the condition being truthy. Usually, the other form is preferred: `while(…) {…}`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Il ciclo "for" 
 
+<<<<<<< HEAD
 Il ciclo `for` è spesso il più utilizzato.
+=======
+The `for` loop is the most commonly used loop.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 La sua forma è del tipo:
 
@@ -102,14 +130,28 @@ for (let i = 0; i < 3; i++) { // shows 0, then 1, then 2
 }
 ```
 
+<<<<<<< HEAD
 Esaminiamo l'istruzione `for` parte per parte:
+=======
+Let's examine the `for` statement part-by-part:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 | Parte |          |                                                                            |
 |-------|----------|----------------------------------------------------------------------------|
+<<<<<<< HEAD
 | begin | `i = 0`    | Viene eseguito una volta all'entrata nel ciclo.                          |
 | condition | `i < 3`| Viene controllata prima di ogni iterazione del ciclo, se fallisce il ciclo si interrompe.|
 | step| `i++`      | Viene eseguito prima del corpo ad ogni iterazione, ma dopo il controllo della condizione.|
 | body | `alert(i)`| Viene eseguito fino a che vale la condizione.
+=======
+| begin | `i = 0`    | Executes once upon entering the loop.                                      |
+| condition | `i < 3`| Checked before every loop iteration. If false, the loop stops.              |
+| step| `i++`      | Executes after the body on each iteration but before the condition check. |
+| body | `alert(i)`| Runs again and again while the condition is truthy.                         |
+
+
+The general loop algorithm works like this:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ```
 Eseguiamo begin
 → (if condition → run body and run step)
@@ -118,9 +160,15 @@ Eseguiamo begin
 → ...
 ```
 
+<<<<<<< HEAD
 Se i cicli vi sono nuovi, allora forse vi sarà d'aiuto tornare indietro agli esempi e provare a riprodurli passo-passo su un foglio di carta.
 
 Questo è quello che succede esattamente nel nostro codice:
+=======
+If you are new to loops, it could help to go back to the example and reproduce how it runs step-by-step on a piece of paper.
+
+Here's exactly what happens in our case:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 // for (let i = 0; i < 3; i++) alert(i)
@@ -136,8 +184,13 @@ if (i < 3) { alert(i); i++ }
 // ...finish, because now i == 3
 ```
 
+<<<<<<< HEAD
 ````smart header="Dichiarazioni di variabili inline"
 Qui il "counter" è una variabile `i` che viene dichiarata all'interno del ciclo. Questa viene chiamata una dichiarazione di una variabile "inline". Queste variabili sono visibile solo all'interno del ciclo.
+=======
+````smart header="Inline variable declaration"
+Here, the "counter" variable `i` is declared right in the loop. This is called an "inline" variable declaration. Such variables are visible only inside the loop.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 for (*!*let*/!* i = 0; i < 3; i++) {
@@ -146,7 +199,11 @@ for (*!*let*/!* i = 0; i < 3; i++) {
 alert(i); // error, no such variable
 ```
 
+<<<<<<< HEAD
 Invece che definire una nuova variabile, possiamo utilizzarne una già esistente:
+=======
+Instead of defining a variable, we could use an existing one:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let i = 0;
@@ -187,9 +244,15 @@ for (; i < 3;) {
 }
 ```
 
+<<<<<<< HEAD
 Il ciclo diventa uguale ad un `while (i < 3)`.
 
 Possiamo rimuovere tutto, questo genererà un ciclo infinito:
+=======
+This makes the loop identical to `while (i < 3)`.
+
+We can actually remove everything, creating an infinite loop:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 for (;;) {
@@ -197,15 +260,27 @@ for (;;) {
 }
 ```
 
+<<<<<<< HEAD
 Nota che le due `;` del ciclo `for` devono essere presenti, altrimenti sarebbe un errore di sintassi.
+=======
+Please note that the two `for` semicolons `;` must be present. Otherwise, there would be a syntax error.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Interromper un ciclo 
 
+<<<<<<< HEAD
 Normalmente un ciclo termina quando la condizione diventa falsa.
 
 Ma è possibile forzare l'uscita in qualsiasi momento. C'è una speciale direttiva `break` per fare questo.
 
 Ad esempio, il ciclo sotto chiede all'utente una serie di numeri, ma "termina" quando nessun numero viene inserito: 
+=======
+Normally, a loop exits when its condition becomes falsy.
+
+But we can force the exit at any time using the special `break` directive.
+
+For example, the loop below asks the user for a series of numbers, "breaking" when no number is entered:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 let sum = 0;
@@ -224,15 +299,27 @@ while (true) {
 alert( 'Sum: ' + sum );
 ```
 
+<<<<<<< HEAD
 La direttiva `break` viene attivata alla linea `(*)` se l'utente inserisce una linea vuota o annulla la procedura di input. Questo fermerà il ciclo immediatamente, passando il controllo alla prima linea successiva al ciclo. In questo caso, `alert`.
 
 La combinazione "ciclo infinito + `break` quando necessario" è ottima per le situazioni in cui la condizione deve essere verificata in un punto differente dall'inizio/fine del ciclo, che può essere a metà, o in qualsiasi altro punto del corpo.
+=======
+The `break` directive is activated at the line `(*)` if the user enters an empty line or cancels the input. It stops the loop immediately, passing control to the first line after the loop. Namely, `alert`.
+
+The combination "infinite loop + `break` as needed" is great for situations when a loop's condition must be checked not in the beginning or end of the loop, but in the middle or even in several places of its body.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Vai alla prossima iterazione [#continue]
 
+<<<<<<< HEAD
 La direttiva `continue` è una versione leggera del `break`. Non blocca l'intero ciclo. Invece interrompe solo l'iterazione corrente e forza il ciclo a reiniziare dall'iterazione successiva (se la condizione è soddisfatta).
 
 Possiamo utilizzarla se abbiamo finito con le operazioni che ci interessano in una data iterazione e vogliamo passare a quella seguente.
+=======
+The `continue` directive is a "lighter version" of `break`. It doesn't stop the whole loop. Instead, it stops the current iteration and forces the loop to start a new one (if the condition allows).
+
+We can use it if we're done with the current iteration and would like to move on to the next one.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Il ciclo sotto usa `continue` per ritornare i valori dispari:
 
@@ -246,10 +333,17 @@ for (let i = 0; i < 10; i++) {
 }
 ```
 
+<<<<<<< HEAD
 Per i valori pari di `i`, la direttiva `continue` interrompe l'esecuzione del corpo e passa il controllo alla successiva iterazione del `for` (con il numero successivo). Quindi l'`alert` viene chiamato solo con i valori dispari.
 
 ````smart header="La direttiva `continue` aiuta a diminuire i livelli di nidificazione"
 Un ciclo che mostra i valori dispari potrebbe essere:
+=======
+For even values of `i`, the `continue` directive stops executing the body and passes control to the next iteration of `for` (with the next number). So the `alert` is only called for odd values.
+
+````smart header="The `continue` directive helps decrease nesting"
+A loop that shows odd values could look like this:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 for (let i = 0; i < 10; i++) {
@@ -261,6 +355,7 @@ for (let i = 0; i < 10; i++) {
 }
 ```
 
+<<<<<<< HEAD
 Dal punto di vista tecnico è identico all'esempio sopra. Ovviamente possiamo raccogliere il codice in un blocco `if` piuttosto di usare `continue`.
 
 Ma come effetto collaterale abbiamo aggiunto un livello di annidamento ulteriore (la chiamata `alert` all'interno delle parentesi graffe). Se il codice dentro `if` è più lungo di un paio di righe, si rischia di perdere in leggibilità.
@@ -268,6 +363,15 @@ Ma come effetto collaterale abbiamo aggiunto un livello di annidamento ulteriore
 
 ````warn header="Vietato `break/continue` alla desta di '?'"
 Da notare che questo costrutto sintattico non è un espressione e non può quindi essere utilizzato con l'operatore ternario `?`. In particolare, direttive come  `break/continue` non sono concesse.
+=======
+From a technical point of view, this is identical to the example above. Surely, we can just wrap the code in an `if` block instead of using `continue`.
+
+But as a side-effect, this created one more level of nesting (the `alert` call inside the curly braces). If the code inside of`if` is longer than a few lines, that may decrease the overall readability.
+````
+
+````warn header="No `break/continue` to the right side of '?'"
+Please note that syntax constructs that are not expressions cannot be used with the ternary operator `?`. In particular, directives such as `break/continue` aren't allowed there.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio, se prendiamo questo codice:
 
@@ -279,24 +383,39 @@ if (i > 5) {
 }
 ```
 
+<<<<<<< HEAD
 ...E lo riscriviamo utilizzando l'operatore ternario:
+=======
+...and rewrite it using a question mark:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 
 ```js no-beautify
-(i > 5) ? alert(i) : *!*continue*/!*; // continue not allowed here
+(i > 5) ? alert(i) : *!*continue*/!*; // continue isn't allowed here
 ```
 
+<<<<<<< HEAD
 ...Questo smetterà di funzionare. Codice scritto cosi vi darà un errore di sintassi:
 
 
 Questa è solo un'altra ragione per cui non utilizzare l'operatore ternario `?` piuttosto che `if`.
+=======
+...it stops working. Code like this will give a syntax error:
+
+
+This is just another reason not to use the question mark operator `?` instead of `if`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ````
 
 ## Etichette break/continue
 
 Qualche volta abbiamo bisogno di uscire da una serie di cicli annidati in un colpo solo.
 
+<<<<<<< HEAD
 Ad esempio, nel codice sotto cicliamo su `i` e `j` eseguendo prompt sulle coordinate `(i, j)` da `(0,0)` a `(3,3)`:
+=======
+For example, in the code below we loop over `i` and `j`, prompting for the coordinates `(i, j)` from `(0,0)` to `(3,3)`:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run no-beautify
 for (let i = 0; i < 3; i++) {
@@ -315,7 +434,11 @@ alert('Done!');
 
 Abbiamo bisogno di un modo per bloccare il processo se l'utente annulla l'input.
 
+<<<<<<< HEAD
 Un semplice `break` dopo `input` interromperebbe solo il break interno. Questo non è sufficiente. Le etichette ci vengono in soccorso.
+=======
+The ordinary `break` after `input` would only break the inner loop. That's not sufficient--labels, come to the rescue!
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Una *label* (etichetta) è un identificatore seguito da ":" posti prima di un ciclo:
 ```js
@@ -324,9 +447,13 @@ labelName: for (...) {
 }
 ```
 
+<<<<<<< HEAD
 L'istruzione `break <labelName>` nel ciclo uscirà fino alla label.
 
 Come nell'esempio:
+=======
+The `break <labelName>` statement in the loop below breaks out to the label:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run no-beautify
 *!*outer:*/!* for (let i = 0; i < 3; i++) {
@@ -344,7 +471,11 @@ Come nell'esempio:
 alert('Done!');
 ```
 
+<<<<<<< HEAD
 Nel codice sopra `break outer` va alla ricerca della label (etichetta) chiamata `outer` ed esce dal ciclo.
+=======
+In the code above, `break outer` looks upwards for the label named `outer` and breaks out of that loop.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Quindi il controllo va da `(*)` a `alert('Done!')`.
 
@@ -355,10 +486,17 @@ outer:
 for (let i = 0; i < 3; i++) { ... }
 ```
 
+<<<<<<< HEAD
 Anche la direttiva `continue` può essere utilizzata con un'etichetta. In questo caso l'esecuzione salta alla prossima iterazione del ciclo con quell'etichetta.
 
 ````warn header="Label non equivalgono a \"goto\""
 Le Label non permettono di saltare in un punto arbitrario del codice.
+=======
+The `continue` directive can also be used with a label. In this case, code execution jumps to the next iteration of the labeled loop.
+
+````warn header="Labels are not a \"goto\""
+Labels do not allow us to jump into an arbitrary place in the code.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio, non è possibile fare:
 ```js
@@ -367,7 +505,11 @@ break label;  // jumps to label? No.
 label: for (...)
 ```
 
+<<<<<<< HEAD
 La chiamata a `break/continue` è possibile solo dall'interno di un ciclo, e l'etichetta deve essere da qualche parte sopra la chiamata.
+=======
+A call to `break/continue` is only possible from inside a loop and the label must be somewhere above the directive.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ````
 
 ## Summary
@@ -380,6 +522,12 @@ Abbiamo coperto 3 tipi di cicli:
 
 Per crere un ciclo infinito, si usa il costrutto `while(true)`. Questo tipo di cicli, come tutti gli altri, possono essere interrotti con la direttiva `break`.
 
+<<<<<<< HEAD
 Se non si ha più intenzione di fare nulla nell'iterazione corrente e si vuole quindi saltare alla successiva, la direttiva `continue` lo consente.
 
 `break/continue` supportano le etichette prima del ciclo. Un etichetta è l'unico modo per `break/continue` di uscire da cicli annidati ed andare al ciclo esterno.
+=======
+If we don't want to do anything in the current iteration and would like to forward to the next one, we can use the `continue` directive.
+
+`break/continue` support labels before the loop. A label is the only way for `break/continue` to escape a nested loop to go to an outer one.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/02-first-steps/13-switch/article.md b/1-js/02-first-steps/13-switch/article.md
index 601293a03..9de4db009 100644
--- a/1-js/02-first-steps/13-switch/article.md
+++ b/1-js/02-first-steps/13-switch/article.md
@@ -148,7 +148,7 @@ Mettiamo in risalto che il confronto di uguaglianza è sempre stretto. I valori
 Ad esempio, consideriamo il codice:
 
 ```js run
-let arg = prompt("Enter a value?")
+let arg = prompt("Enter a value?");
 switch (arg) {
   case '0':
   case '1':
@@ -163,7 +163,7 @@ switch (arg) {
     alert( 'Never executes!' );
     break;
   default:
-    alert( 'An unknown value' )
+    alert( 'An unknown value' );
 }
 ```
 
diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index b45ecfa75..cc857c4bd 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -128,7 +128,11 @@ Le variabili dichiarate all'esterno di qualsiasi funzione, come `userName` nel c
 
 Le variabili globali sono visibili a qualsiasi funzione (se non sono oscurate da quelle locali).
 
+<<<<<<< HEAD
 Solitamente, una funzione dichiara tutte le variabili necessarie per svolgere il compito. Le variabili locali vengono utilizzate per memorizzare dati relativi al progetto, quindi quando è importante che queste siano accessibili in qualsiasi punto del codice. I codici moderni cercano di evitare le variabili globali. La maggior parte delle variabili appartengono quindi a delle specifiche funzioni.
+=======
+Usually, a function declares all variables specific to its task. Global variables only store project-level data, and it's important that these variables are accessible from anywhere. Modern code has few or no globals. Most variables reside in their functions.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ```
 
 ## Parametri
@@ -204,8 +208,15 @@ function showMessage(from, text = anotherFunction()) {
 }
 ```
 
+<<<<<<< HEAD
 ```smart header="Valutazione dei parametri di default"
 In JavaScript, un parametro di default viene valutato ogni volta che viene chiamata una funzione senza i rispettivi parametri. Nell'esempio sopra, `anotherFunctions()` viene richiamata ogni volta che `someMessage()` viene richiamata senza il parametro `text`. Questo è in contrasto con altri linguaggi come Python, dove ogni parametro di default viene valutato solo durante la fase di interpretazione.
+=======
+```smart header="Evaluation of default parameters"
+
+In JavaScript, a default parameter is evaluated every time the function is called without the respective parameter. In the example above, `anotherFunction()` is called every time `showMessage()` is called without the `text` parameter. This is in contrast to some other languages like Python, where any default parameters are evaluated only once during the initial interpretation.
+
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ```
 
 
@@ -370,9 +381,15 @@ Due azioni separate solitamente meritano due funzioni diverse, anche se molto sp
 
 Un paio di esempi che non rispettano queste regole:
 
+<<<<<<< HEAD
 - `getAge` -- sarebbe un pessimo nome se mostrasse un `alert` con l'età (dovrebbe solo restituirlo).
 - `createForm` -- sarebbe un pessimo nome se modificasse il documento, aggiungendo il form (infatti dovrebbe solo crearlo e restituirlo).
 - `checkPermission` -- sarebbe un pessimo nome se mostrasse il messaggio `access granted/denied` (dovrebbe solo eseguire il controllo e ritornare il risultato).
+=======
+- `getAge` -- would be bad if it shows an `alert` with the age (should only get).
+- `createForm` -- would be bad if it modifies the document, adding a form to it (should only create it and return).
+- `checkPermission` -- would be bad if it displays the `access granted/denied` message (should only perform the check and return the result).
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Questi esempi assumono i significati comuni dei prefissi. Il loro significato dipende da voi e dal vostro team. E' comunque normale che il tuo codice abbia caratteristiche diverse. Ma è fondamentale avere una firma il cui prefisso sia sensato, che faccia capire cosa un determinato tipo di funzione può o non può fare. Tutte le funzione che iniziano con lo stesso prefisso dovrebbero seguire determinate regole. E' fondamentale che il team condivida queste informazioni.
 ```
diff --git a/1-js/02-first-steps/14-function-basics/function_basics.png b/1-js/02-first-steps/14-function-basics/function_basics.png
index 5f3505811..f5e6f9418 100644
Binary files a/1-js/02-first-steps/14-function-basics/function_basics.png and b/1-js/02-first-steps/14-function-basics/function_basics.png differ
diff --git a/1-js/02-first-steps/14-function-basics/function_basics@2x.png b/1-js/02-first-steps/14-function-basics/function_basics@2x.png
index e2fe5bac0..c31b2636a 100644
Binary files a/1-js/02-first-steps/14-function-basics/function_basics@2x.png and b/1-js/02-first-steps/14-function-basics/function_basics@2x.png differ
diff --git a/1-js/02-first-steps/16-javascript-specials/article.md b/1-js/02-first-steps/16-javascript-specials/article.md
index 573c434ee..506a6089f 100644
--- a/1-js/02-first-steps/16-javascript-specials/article.md
+++ b/1-js/02-first-steps/16-javascript-specials/article.md
@@ -102,8 +102,13 @@ Di più in: <info:variables> e <info:types>.
 
 Abbiamo utilizzato solo il browser come ambiente di sviluppo, quindi le interfacce di base saranno:
 
+<<<<<<< HEAD
 [`prompt(question[, default])`](mdn:api/Window/prompt)
 : Pone una domanda `question`, e ritorna quello che l'utente ha inserito oppure `null` se ha premuto "cancel".
+=======
+[`prompt(question, [default])`](mdn:api/Window/prompt)
+: Ask a `question`, and return either what the visitor entered or `null` if they pressed "cancel".
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 [`confirm(question)`](mdn:api/Window/confirm)
 : Pone una domanda `question` e fornisce la possibilità di scegliere tra Ok e Cancel. La scelta viene ritornata come `true/false`.
@@ -148,8 +153,13 @@ Bit a Bit
 Ternari
 : C'è un solo operatore con tre parametri: `cond ? resultA : resultB`. Se `cond` è vera, ritorna `resultA`, altrimenti `resultB`.
 
+<<<<<<< HEAD
 Operatori logici
 : AND logico `&&` e OR `||` eseguono delle valutazioni locali e ritornano un valore quando si fermano.
+=======
+Logical operators
+: Logical AND `&&` and OR `||` perform short-circuit evaluation and then return the value where it stopped. Logical NOT `!` converts the operand to boolean type and returns the inverse value.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Confronto
 : Confronto di uguaglianza `==` valori di tipi diversi vengono convertiti in numeri (ad eccezione di `null` e `undefined` che si eguagliano tra di loro e con nient'altro), quindi questi sono uguali:
@@ -167,8 +177,13 @@ Confronto
 
     Maggiore/minore confrontano le stringhe carattere per carattere, gli altri valori vengono convertiti a numeri.
 
+<<<<<<< HEAD
 Operatori logici
 : Ce ne sono altri, come l'operatore virgola.
+=======
+Other operators
+: There are few others, like a comma operator.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Di più in: <info:operators>, <info:comparison>, <info:logical-operators>.
 
diff --git a/1-js/03-code-quality/01-debugging-chrome/article.md b/1-js/03-code-quality/01-debugging-chrome/article.md
index 514f36060..f4924999e 100644
--- a/1-js/03-code-quality/01-debugging-chrome/article.md
+++ b/1-js/03-code-quality/01-debugging-chrome/article.md
@@ -56,11 +56,19 @@ Un *breakpoint* è un punto del codice in cui il debugger si metterà in pausa a
 
 Mentre il codice è in pause, è possibile esaminare le variabili, eseguire comandi tramite la console etc. In altre parole, possiamo eseguire il debug.
 
+<<<<<<< HEAD
 Possiamo anche visualizzare la lista dei breakpoint nel pannello di destra. Questo pannello può risultare utile quando abbiamo più breakpoint in file diversi. Infatti ci consente di:
 - Salatare rapidamente ad un breakpoint (cliccando sopra al nome del breakpoint che ci interessa).
 - Disabilitare temporaneamente un breakpoint semplicemente togliendo la spunta.
 - Rimuovere breakpoint cliccando con il tasto destro e selezionando Rimuovi.
 - ...E molto altro.
+=======
+We can always find a list of breakpoints in the right pane. That's useful when we have many breakpoints in various files. It allows us to:
+- Quickly jump to the breakpoint in the code (by clicking on it in the right pane).
+- Temporarily disable the breakpoint by unchecking it.
+- Remove the breakpoint by right-clicking and selecting Remove.
+- ...And so on.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```smart header="Breakpoint condizionali"
 *Tasto destro* sul numero della riga ci consente di creare un breakpoint *condizionale*. Che viene attivato solo quando l'espressione fornita risulta vera.
@@ -169,10 +177,17 @@ Se abbiamo abbastanza log nel nostro codice, possiamo vedere cosa sta accadendo
 
 ## Riepilogo
 
+<<<<<<< HEAD
 Come abbiamo visto, ci sono tre diversi modi di metter in pausa uno script:
 1. Un breakpoint.
 2. L'istruzione `debugger`.
 3. Un errore (solo se gli strumenti sviluppatore sono aperti ed è attivo il bottone <span class="devtools" style="background-position:-264px -4px"></span>)
+=======
+As we can see, there are three main ways to pause a script:
+1. A breakpoint.
+2. The `debugger` statements.
+3. An error (if dev tools are open and the button <span class="devtools" style="background-position:-264px -4px"></span> is "on").
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Cosi possiamo esaminare le variabili e capire cosa è andato male durante l'esecuzione.
 
diff --git a/1-js/03-code-quality/01-debugging-chrome/chrome-open-sources.png b/1-js/03-code-quality/01-debugging-chrome/chrome-open-sources.png
index efa3c19df..abc59905a 100644
Binary files a/1-js/03-code-quality/01-debugging-chrome/chrome-open-sources.png and b/1-js/03-code-quality/01-debugging-chrome/chrome-open-sources.png differ
diff --git a/1-js/03-code-quality/01-debugging-chrome/chrome-open-sources@2x.png b/1-js/03-code-quality/01-debugging-chrome/chrome-open-sources@2x.png
index e184bdd01..546615e30 100644
Binary files a/1-js/03-code-quality/01-debugging-chrome/chrome-open-sources@2x.png and b/1-js/03-code-quality/01-debugging-chrome/chrome-open-sources@2x.png differ
diff --git a/1-js/03-code-quality/01-debugging-chrome/chrome-sources-breakpoint.png b/1-js/03-code-quality/01-debugging-chrome/chrome-sources-breakpoint.png
index 2fe449c9b..caf60ebb6 100644
Binary files a/1-js/03-code-quality/01-debugging-chrome/chrome-sources-breakpoint.png and b/1-js/03-code-quality/01-debugging-chrome/chrome-sources-breakpoint.png differ
diff --git a/1-js/03-code-quality/01-debugging-chrome/chrome-sources-breakpoint@2x.png b/1-js/03-code-quality/01-debugging-chrome/chrome-sources-breakpoint@2x.png
index e4abc89d1..3f628b6ff 100644
Binary files a/1-js/03-code-quality/01-debugging-chrome/chrome-sources-breakpoint@2x.png and b/1-js/03-code-quality/01-debugging-chrome/chrome-sources-breakpoint@2x.png differ
diff --git a/1-js/03-code-quality/01-debugging-chrome/chrome-sources-console.png b/1-js/03-code-quality/01-debugging-chrome/chrome-sources-console.png
index 98b22e777..0fc22b2ea 100644
Binary files a/1-js/03-code-quality/01-debugging-chrome/chrome-sources-console.png and b/1-js/03-code-quality/01-debugging-chrome/chrome-sources-console.png differ
diff --git a/1-js/03-code-quality/01-debugging-chrome/chrome-sources-console@2x.png b/1-js/03-code-quality/01-debugging-chrome/chrome-sources-console@2x.png
index 3269a80f0..f01a7d101 100644
Binary files a/1-js/03-code-quality/01-debugging-chrome/chrome-sources-console@2x.png and b/1-js/03-code-quality/01-debugging-chrome/chrome-sources-console@2x.png differ
diff --git a/1-js/03-code-quality/01-debugging-chrome/chrome-sources-debugger-pause.png b/1-js/03-code-quality/01-debugging-chrome/chrome-sources-debugger-pause.png
index 719293d2e..424ca26b0 100644
Binary files a/1-js/03-code-quality/01-debugging-chrome/chrome-sources-debugger-pause.png and b/1-js/03-code-quality/01-debugging-chrome/chrome-sources-debugger-pause.png differ
diff --git a/1-js/03-code-quality/01-debugging-chrome/chrome-sources-debugger-pause@2x.png b/1-js/03-code-quality/01-debugging-chrome/chrome-sources-debugger-pause@2x.png
index 5c22ab361..04cc849d1 100644
Binary files a/1-js/03-code-quality/01-debugging-chrome/chrome-sources-debugger-pause@2x.png and b/1-js/03-code-quality/01-debugging-chrome/chrome-sources-debugger-pause@2x.png differ
diff --git a/1-js/03-code-quality/01-debugging-chrome/chrome-sources-debugger-trace-1.png b/1-js/03-code-quality/01-debugging-chrome/chrome-sources-debugger-trace-1.png
index 1848ccfac..00507833a 100644
Binary files a/1-js/03-code-quality/01-debugging-chrome/chrome-sources-debugger-trace-1.png and b/1-js/03-code-quality/01-debugging-chrome/chrome-sources-debugger-trace-1.png differ
diff --git a/1-js/03-code-quality/01-debugging-chrome/chrome-sources-debugger-trace-1@2x.png b/1-js/03-code-quality/01-debugging-chrome/chrome-sources-debugger-trace-1@2x.png
index fcabf722e..d2a38bf0c 100644
Binary files a/1-js/03-code-quality/01-debugging-chrome/chrome-sources-debugger-trace-1@2x.png and b/1-js/03-code-quality/01-debugging-chrome/chrome-sources-debugger-trace-1@2x.png differ
diff --git a/1-js/03-code-quality/01-debugging-chrome/chrome-tabs.png b/1-js/03-code-quality/01-debugging-chrome/chrome-tabs.png
index ff91c531f..df9e13f3f 100644
Binary files a/1-js/03-code-quality/01-debugging-chrome/chrome-tabs.png and b/1-js/03-code-quality/01-debugging-chrome/chrome-tabs.png differ
diff --git a/1-js/03-code-quality/01-debugging-chrome/chrome-tabs@2x.png b/1-js/03-code-quality/01-debugging-chrome/chrome-tabs@2x.png
index 09b10bf48..5793bd059 100644
Binary files a/1-js/03-code-quality/01-debugging-chrome/chrome-tabs@2x.png and b/1-js/03-code-quality/01-debugging-chrome/chrome-tabs@2x.png differ
diff --git a/1-js/03-code-quality/02-coding-style/1-style-errors/solution.md b/1-js/03-code-quality/02-coding-style/1-style-errors/solution.md
index 7b6c32445..a5f9f9f4b 100644
--- a/1-js/03-code-quality/02-coding-style/1-style-errors/solution.md
+++ b/1-js/03-code-quality/02-coding-style/1-style-errors/solution.md
@@ -4,22 +4,22 @@ Avrete notato:
 ```js no-beautify
 function pow(x,n)  // <- no space between arguments
 {  // <- figure bracket on a separate line
-  let result=1;   // <- no spaces to the both sides of =
+  let result=1;   // <- no spaces before or after =
   for(let i=0;i<n;i++) {result*=x;}   // <- no spaces
   // the contents of { ... } should be on a new line
   return result;
 }
 
 let x=prompt("x?",''), n=prompt("n?",'') // <-- technically possible,
-// but better make it 2 lines, also there's no spaces and ;
+// but better make it 2 lines, also there's no spaces and missing ;
 if (n<0)  // <- no spaces inside (n < 0), and should be extra line above it
 {   // <- figure bracket on a separate line
-  // below - a long line, may be worth to split into 2 lines
+  // below - long lines can be split into multiple lines for improved readability
   alert(`Power ${n} is not supported, please enter an integer number greater than zero`);
 }
 else // <- could write it on a single line like "} else {"
 {
-  alert(pow(x,n))  // no spaces and ;
+  alert(pow(x,n))  // no spaces and missing ;
 }
 ```
 
diff --git a/1-js/03-code-quality/02-coding-style/article.md b/1-js/03-code-quality/02-coding-style/article.md
index f64ad54eb..e720902db 100644
--- a/1-js/03-code-quality/02-coding-style/article.md
+++ b/1-js/03-code-quality/02-coding-style/article.md
@@ -255,7 +255,11 @@ Questo perché quando leggiamo il codice vogliamo prima di tutto sapere *cosa fa
 
 Una guida di stile contiene  regole generali riguardo a "come scrivere" il codice, ad esempio quali apici utilizzare, di quanti spazi indentare, quando andare a capo, etc. Molti altri dettagli.
 
+<<<<<<< HEAD
 Quando tutti i membri del team utilizzano lo stesso stile tende ad essere uniforme.
+=======
+When all members of a team use the same style guide, the code looks uniform, regardless of which team member wrote it.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Certamente, un team può utilizzare il proprio stile guida. Molte volte non serve. Ci sono molte opzioni tra cui scegliere, quindi scegliere tra una di queste generalmente è la scelta migliore.
 
@@ -287,10 +291,17 @@ Molti linter sono integrati negli editor più popolari: è sufficiente attivare
 
 Ad esempio, per ESLint dovreste seguire quanto segue:
 
+<<<<<<< HEAD
 1. Installare [Node.JS](https://nodejs.org/).
 2. Installare ESLint con il comando `npm install -g eslint` (npm è package installer di JavaScript).
 3. Create un file di configurazione e rinominatelo `.eslintrc` nella root del vostro progetto JavaScript (la cartella che contiene tutti i file).
 4. Installa/abilita il plugin per il tuo editor per integrare ESLint. La maggior parte degli editor ne ha uno.
+=======
+1. Install [Node.js](https://nodejs.org/).
+2. Install ESLint with the command `npm install -g eslint` (npm is a JavaScript package installer).
+3. Create a config file named `.eslintrc` in the root of your JavaScript project (in the folder that contains all your files).
+4. Install/enable the plugin for your editor that integrates with ESLint. The majority of editors have one.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Qui un esempio di di un file `.eslintrc`:
 
diff --git a/1-js/03-code-quality/02-coding-style/code-style.png b/1-js/03-code-quality/02-coding-style/code-style.png
index a9ae4b98e..1c6d355dd 100644
Binary files a/1-js/03-code-quality/02-coding-style/code-style.png and b/1-js/03-code-quality/02-coding-style/code-style.png differ
diff --git a/1-js/03-code-quality/02-coding-style/code-style@2x.png b/1-js/03-code-quality/02-coding-style/code-style@2x.png
index be9b99dc2..832623d9c 100644
Binary files a/1-js/03-code-quality/02-coding-style/code-style@2x.png and b/1-js/03-code-quality/02-coding-style/code-style@2x.png differ
diff --git a/1-js/03-code-quality/02-coding-style/figure-bracket-style.png b/1-js/03-code-quality/02-coding-style/figure-bracket-style.png
index 112c2803e..b04db65c6 100644
Binary files a/1-js/03-code-quality/02-coding-style/figure-bracket-style.png and b/1-js/03-code-quality/02-coding-style/figure-bracket-style.png differ
diff --git a/1-js/03-code-quality/02-coding-style/figure-bracket-style@2x.png b/1-js/03-code-quality/02-coding-style/figure-bracket-style@2x.png
index ce6e75c4d..0e994ca4b 100644
Binary files a/1-js/03-code-quality/02-coding-style/figure-bracket-style@2x.png and b/1-js/03-code-quality/02-coding-style/figure-bracket-style@2x.png differ
diff --git a/1-js/03-code-quality/04-ninja-code/article.md b/1-js/03-code-quality/04-ninja-code/article.md
index 1e123c775..648b8d7bf 100644
--- a/1-js/03-code-quality/04-ninja-code/article.md
+++ b/1-js/03-code-quality/04-ninja-code/article.md
@@ -81,7 +81,11 @@ Quando scegliete un nome cercare di utilizzare parole più astratte possibili. C
 
     Dategli una possibilità. Un giovane iniziato potrebbe pensare -- sono veramente utili ad un ninja questi nomi? Infatti lo sono!
 
+<<<<<<< HEAD
     Certamente il nome della variabile contiene comunque un significato. Infatti informa riguardo cosa è contenuto nella variabile: una stringa, un numero o qualcos'altro. Ma quando un estraneo cercherà di capire il codice, rimarrà sorpreso scoprendo che in realtà non forniscono alcuna informazione! Quindi fallirà nel suo intento di modificare il vostro codice.
+=======
+    Sure, the variable name still means something. It says what's inside the variable: a string, a number or something else. But when an outsider tries to understand the code, they'll be surprised to see that there's actually no information at all! And will ultimately fail to alter your well-thought code.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
     Il tipo del valore è semplice da trovare con un debugger. Ma qual'è il significato della variabile? Quale numero/stringa contiene?
 
@@ -151,7 +155,13 @@ function ninjaFunction(elem) {
 }
 ```
 
+<<<<<<< HEAD
 Un programmatore esterno che vorrebbe provare ad interagire con `elem` nella seconda parte della funzione, rimarrà sorpreso... Solamente in fase di debugging , dopo aver esaminato attentamente il codice si renderà conto che stava lavorando con un clone!
+=======
+A fellow programmer who wants to work with `elem` in the second half of the function will be surprised... Only during the debugging, after examining the code they will find out that they're working with a clone!
+
+Seen in code regularly. Deadly effective even against an experienced ninja. 
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Se ripetuto regolarmente nel codice, diventa letale anche contro i ninja più esperti. 
 
@@ -194,7 +204,11 @@ function render() {
 
 Un programmatore che si trova dentro `render` probabilmente non si accorgerà che la variabile locale `user` sta nascondendo quella esterna.
 
+<<<<<<< HEAD
 Quindi potrebbe provare a lavorare con `user` pensando erroneamente che sia quella esterna, quella con il risultato di `authenticateUser()`... La trappola è servita! Addio debugger...
+=======
+Then they'll try to work with `user` assuming that it's the external variable, the result of `authenticateUser()`... The trap is sprung! Hello, debugger...
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 
 ## Side-effect ovunque!
diff --git a/1-js/03-code-quality/05-testing-mocha/article.md b/1-js/03-code-quality/05-testing-mocha/article.md
index 8009cc25b..a528486b9 100644
--- a/1-js/03-code-quality/05-testing-mocha/article.md
+++ b/1-js/03-code-quality/05-testing-mocha/article.md
@@ -117,7 +117,7 @@ Per il futuro, vi faccio notare che ci sono dei test più avanzati, come [karma]
 Proviamo a fornire una semplice implementazione di `pow`, per passare il test:
 
 ```js
-function pow() {
+function pow(x, n) {
   return 8; // :) we cheat!
 }
 ```
@@ -233,7 +233,7 @@ Il raggruppamento viene effettuato con un `describe` annidato:
 describe("pow", function() {
 
 *!*
-  describe("raises x to power n", function() {
+  describe("raises x to power 3", function() {
 */!*
 
     function makeTest(x) {
@@ -296,7 +296,11 @@ Testing finished – after all tests (after)
 
 [edit src="beforeafter" title="Open the example in the sandbox."]
 
+<<<<<<< HEAD
 Solitamente, `beforeEach/afterEach` (`before/each`) vengono utilizzari per eseguire inizializzazioni, azzerare i contatori o fare qualcosa prima di iniziare il prossimo test.
+=======
+Usually, `beforeEach/afterEach` (`before/after`) are used to perform initialization, zero out counters or do something else between the tests (or test groups).
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ````
 
 ## Estendere le spec
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-2.view/index.html b/1-js/03-code-quality/05-testing-mocha/pow-2.view/index.html
index d82a79dca..e8d6be23d 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-2.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/pow-2.view/index.html
@@ -20,7 +20,7 @@
 <body>
 
   <script>
-    function pow() {
+    function pow(x, n) {
       return 8; // :) we cheat!
     }
   </script>
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-4.view/test.js b/1-js/03-code-quality/05-testing-mocha/pow-4.view/test.js
index 10a032d03..e5ce2ce43 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-4.view/test.js
+++ b/1-js/03-code-quality/05-testing-mocha/pow-4.view/test.js
@@ -1,6 +1,6 @@
 describe("pow", function() {
 
-  describe("raises x to power n", function() {
+  describe("raises x to power 3", function() {
 
     function makeTest(x) {
       let expected = x * x * x;
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-full.view/test.js b/1-js/03-code-quality/05-testing-mocha/pow-full.view/test.js
index a5a345979..75ff5e99f 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-full.view/test.js
+++ b/1-js/03-code-quality/05-testing-mocha/pow-full.view/test.js
@@ -1,6 +1,6 @@
 describe("pow", function() {
 
-  describe("raises x to power n", function() {
+  describe("raises x to power 3", function() {
 
     function makeTest(x) {
       let expected = x * x * x;
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-nan.view/test.js b/1-js/03-code-quality/05-testing-mocha/pow-nan.view/test.js
index a5a345979..75ff5e99f 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-nan.view/test.js
+++ b/1-js/03-code-quality/05-testing-mocha/pow-nan.view/test.js
@@ -1,6 +1,6 @@
 describe("pow", function() {
 
-  describe("raises x to power n", function() {
+  describe("raises x to power 3", function() {
 
     function makeTest(x) {
       let expected = x * x * x;
diff --git a/1-js/04-object-basics/01-object/3-is-empty/_js.view/solution.js b/1-js/04-object-basics/01-object/3-is-empty/_js.view/solution.js
index e7f63284f..db3283e49 100644
--- a/1-js/04-object-basics/01-object/3-is-empty/_js.view/solution.js
+++ b/1-js/04-object-basics/01-object/3-is-empty/_js.view/solution.js
@@ -1,7 +1,7 @@
 function isEmpty(obj) {
   for (let key in obj) {
-    // if the loop has started, there is a prorty
+    // if the loop has started, there is a property
     return false;
   }
   return true;
-}
\ No newline at end of file
+}
diff --git a/1-js/04-object-basics/01-object/3-is-empty/solution.md b/1-js/04-object-basics/01-object/3-is-empty/solution.md
index 4ec674d9a..a11c57cfb 100644
--- a/1-js/04-object-basics/01-object/3-is-empty/solution.md
+++ b/1-js/04-object-basics/01-object/3-is-empty/solution.md
@@ -1,3 +1,4 @@
+<<<<<<< HEAD
 E' sufficiente eseguire un ciclo e `return false` (ritornare falso) se l'oggetto contiene almeno una proprietà.
 
 ```js
@@ -8,3 +9,6 @@ function isEmpty(obj) {
   return true;
 }
 ```
+=======
+Just loop over the object and `return false` immediately if there's at least one property.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index 0afa44996..f363afd86 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -218,7 +218,11 @@ alert(obj.__proto__); // [object Object], didn't work as intended
 
 Come possiamo veder dal codice, l'assegnazione alla primitiva `5` viene ignorata.
 
+<<<<<<< HEAD
 Questa può diventare una situazione vulnerabile se abbiamo intenzione di memorizzare una coppia chiave-valore in un oggetto, consentendo al visitatore di specificare al chiave.
+=======
+That can become a source of bugs and even vulnerabilities if we intend to store arbitrary key-value pairs in an object, and allow a visitor to specify the keys.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 In questo caso il visitatore potrebbe scegliere "__proto__" come chiave, e l'assegnazione verrebbe rovinata (come abbiamo visto sopra).
 
@@ -336,7 +340,7 @@ Per attraversare tutte le chiavi di un oggetto, esiste una speciale forma di cic
 La sintassi:
 
 ```js
-for(key in object) {
+for (key in object) {
   // executes the body for each key among object properties
 }
 ```
@@ -350,7 +354,7 @@ let user = {
   isAdmin: true
 };
 
-for(let key in user) {
+for (let key in user) {
   // keys
   alert( key );  // name, age, isAdmin
   // values for the keys
@@ -360,7 +364,11 @@ for(let key in user) {
 
 Da notare che tutti i costrutti "for" ci consentono di dichiarare delle variabili di ciclo da utilizzare all'interno del ciclo stesso, come `let key` in questo esempio.
 
+<<<<<<< HEAD
 Inoltre possiamo utilizzare qualsiasi altr variabile al posto di `key`. Ad esempio `"for(let prop in obj)"` è molto utilizzato.
+=======
+Also, we could use another variable name here instead of `key`. For instance, `"for (let prop in obj)"` is also widely used.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 
 ### Ordine degli oggetti
@@ -381,7 +389,7 @@ let codes = {
 };
 
 *!*
-for(let code in codes) {
+for (let code in codes) {
   alert(code); // 1, 41, 44, 49
 }
 */!*
@@ -439,7 +447,7 @@ let codes = {
   "+1": "USA"
 };
 
-for(let code in codes) {
+for (let code in codes) {
   alert( +code ); // 49, 41, 44, 1
 }
 ```
@@ -613,7 +621,7 @@ Possiamo anche utilizzare il metodo [Object.assign](mdn:js/Object/assign).
 La sintassi è:
 
 ```js
-Object.assign(dest[, src1, src2, src3...])
+Object.assign(dest, [src1, src2, src3...])
 ```
 
 - Gli argomenti `dest`, e `src1, ..., srcN` (possono essere anche di più se necessario) sono oggetti.
@@ -719,7 +727,14 @@ Operatori specifici:
 - Per controllare se un una proprietà con un certo nome esiste: `"key" in obj`.
 - Per iterare un oggetto: `for(let key in obj)`.
 
+<<<<<<< HEAD
 Gli oggetti vengono assegnati e copiati per riferimento. In altre parole, la variabile non memorizza il "valore dell'oggetto", ma puittosto un "riferimento" (indirizzo di memoria). Quindi copiando questa variabile o passandola come argomento ad una funzione, fornirà un riferimento all'oggetto e non una copia. Tutte le operazioni effettuate su un oggetto copiato per riferimento (come aggiungere/rimuovere proprietà) vengono effettuate sullo stesso oggetto.
+=======
+Additional operators:
+- To delete a property: `delete obj.prop`.
+- To check if a property with the given key exists: `"key" in obj`.
+- To iterate over an object: `for (let key in obj)` loop.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Per fare una "copia" (un clone) possiamo utilizzare `Object.assign` oppure [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep).
 
diff --git a/1-js/04-object-basics/01-object/object-user-delete.png b/1-js/04-object-basics/01-object/object-user-delete.png
index 688158f9b..8702675c8 100644
Binary files a/1-js/04-object-basics/01-object/object-user-delete.png and b/1-js/04-object-basics/01-object/object-user-delete.png differ
diff --git a/1-js/04-object-basics/01-object/object-user-delete@2x.png b/1-js/04-object-basics/01-object/object-user-delete@2x.png
index e1ef65541..698766bb0 100644
Binary files a/1-js/04-object-basics/01-object/object-user-delete@2x.png and b/1-js/04-object-basics/01-object/object-user-delete@2x.png differ
diff --git a/1-js/04-object-basics/01-object/object-user-empty.png b/1-js/04-object-basics/01-object/object-user-empty.png
index 80fdc0d3b..6b1f27a69 100644
Binary files a/1-js/04-object-basics/01-object/object-user-empty.png and b/1-js/04-object-basics/01-object/object-user-empty.png differ
diff --git a/1-js/04-object-basics/01-object/object-user-empty@2x.png b/1-js/04-object-basics/01-object/object-user-empty@2x.png
index 8db894cb3..5f261eca4 100644
Binary files a/1-js/04-object-basics/01-object/object-user-empty@2x.png and b/1-js/04-object-basics/01-object/object-user-empty@2x.png differ
diff --git a/1-js/04-object-basics/01-object/object-user-isadmin.png b/1-js/04-object-basics/01-object/object-user-isadmin.png
index 4e76eeb76..2ce66a49d 100644
Binary files a/1-js/04-object-basics/01-object/object-user-isadmin.png and b/1-js/04-object-basics/01-object/object-user-isadmin.png differ
diff --git a/1-js/04-object-basics/01-object/object-user-isadmin@2x.png b/1-js/04-object-basics/01-object/object-user-isadmin@2x.png
index b40977690..4a15dac64 100644
Binary files a/1-js/04-object-basics/01-object/object-user-isadmin@2x.png and b/1-js/04-object-basics/01-object/object-user-isadmin@2x.png differ
diff --git a/1-js/04-object-basics/01-object/object-user-props.png b/1-js/04-object-basics/01-object/object-user-props.png
index 2bfdfabdb..b0486e900 100644
Binary files a/1-js/04-object-basics/01-object/object-user-props.png and b/1-js/04-object-basics/01-object/object-user-props.png differ
diff --git a/1-js/04-object-basics/01-object/object-user-props@2x.png b/1-js/04-object-basics/01-object/object-user-props@2x.png
index 4935b59ce..20859fe91 100644
Binary files a/1-js/04-object-basics/01-object/object-user-props@2x.png and b/1-js/04-object-basics/01-object/object-user-props@2x.png differ
diff --git a/1-js/04-object-basics/01-object/object-user.png b/1-js/04-object-basics/01-object/object-user.png
index 16179209f..6215b8207 100644
Binary files a/1-js/04-object-basics/01-object/object-user.png and b/1-js/04-object-basics/01-object/object-user.png differ
diff --git a/1-js/04-object-basics/01-object/object-user@2x.png b/1-js/04-object-basics/01-object/object-user@2x.png
index 720389532..c66fa5159 100644
Binary files a/1-js/04-object-basics/01-object/object-user@2x.png and b/1-js/04-object-basics/01-object/object-user@2x.png differ
diff --git a/1-js/04-object-basics/01-object/object.png b/1-js/04-object-basics/01-object/object.png
index f94d094a9..a853c9c39 100644
Binary files a/1-js/04-object-basics/01-object/object.png and b/1-js/04-object-basics/01-object/object.png differ
diff --git a/1-js/04-object-basics/01-object/object@2x.png b/1-js/04-object-basics/01-object/object@2x.png
index 003c2f6ea..12011ff5c 100644
Binary files a/1-js/04-object-basics/01-object/object@2x.png and b/1-js/04-object-basics/01-object/object@2x.png differ
diff --git a/1-js/04-object-basics/01-object/variable-contains-reference.png b/1-js/04-object-basics/01-object/variable-contains-reference.png
index d6e7fddff..cdd53d0b2 100644
Binary files a/1-js/04-object-basics/01-object/variable-contains-reference.png and b/1-js/04-object-basics/01-object/variable-contains-reference.png differ
diff --git a/1-js/04-object-basics/01-object/variable-contains-reference@2x.png b/1-js/04-object-basics/01-object/variable-contains-reference@2x.png
index 145bad29a..070126198 100644
Binary files a/1-js/04-object-basics/01-object/variable-contains-reference@2x.png and b/1-js/04-object-basics/01-object/variable-contains-reference@2x.png differ
diff --git a/1-js/04-object-basics/01-object/variable-copy-reference.png b/1-js/04-object-basics/01-object/variable-copy-reference.png
index 97510c4b2..287085842 100644
Binary files a/1-js/04-object-basics/01-object/variable-copy-reference.png and b/1-js/04-object-basics/01-object/variable-copy-reference.png differ
diff --git a/1-js/04-object-basics/01-object/variable-copy-reference@2x.png b/1-js/04-object-basics/01-object/variable-copy-reference@2x.png
index a64238a52..e7b994c53 100644
Binary files a/1-js/04-object-basics/01-object/variable-copy-reference@2x.png and b/1-js/04-object-basics/01-object/variable-copy-reference@2x.png differ
diff --git a/1-js/04-object-basics/01-object/variable-copy-value.png b/1-js/04-object-basics/01-object/variable-copy-value.png
index e21af0990..c360a0e13 100644
Binary files a/1-js/04-object-basics/01-object/variable-copy-value.png and b/1-js/04-object-basics/01-object/variable-copy-value.png differ
diff --git a/1-js/04-object-basics/01-object/variable-copy-value@2x.png b/1-js/04-object-basics/01-object/variable-copy-value@2x.png
index 2f0b2f47d..323bc4622 100644
Binary files a/1-js/04-object-basics/01-object/variable-copy-value@2x.png and b/1-js/04-object-basics/01-object/variable-copy-value@2x.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/family-delete-refs.png b/1-js/04-object-basics/02-garbage-collection/family-delete-refs.png
index 5c10f0e47..05160890e 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/family-delete-refs.png and b/1-js/04-object-basics/02-garbage-collection/family-delete-refs.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/family-delete-refs@2x.png b/1-js/04-object-basics/02-garbage-collection/family-delete-refs@2x.png
index 24d29630e..a92fc573b 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/family-delete-refs@2x.png and b/1-js/04-object-basics/02-garbage-collection/family-delete-refs@2x.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/family-no-family.png b/1-js/04-object-basics/02-garbage-collection/family-no-family.png
index a4ce30a35..e60f9b88d 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/family-no-family.png and b/1-js/04-object-basics/02-garbage-collection/family-no-family.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/family-no-family@2x.png b/1-js/04-object-basics/02-garbage-collection/family-no-family@2x.png
index 0d9949839..754903706 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/family-no-family@2x.png and b/1-js/04-object-basics/02-garbage-collection/family-no-family@2x.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/family-no-father-2.png b/1-js/04-object-basics/02-garbage-collection/family-no-father-2.png
index e24dba5b5..823d0a618 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/family-no-father-2.png and b/1-js/04-object-basics/02-garbage-collection/family-no-father-2.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/family-no-father-2@2x.png b/1-js/04-object-basics/02-garbage-collection/family-no-father-2@2x.png
index a6c4ee36a..9e100d522 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/family-no-father-2@2x.png and b/1-js/04-object-basics/02-garbage-collection/family-no-father-2@2x.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/family-no-father.png b/1-js/04-object-basics/02-garbage-collection/family-no-father.png
index df14624bc..5ddb6f68f 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/family-no-father.png and b/1-js/04-object-basics/02-garbage-collection/family-no-father.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/family-no-father@2x.png b/1-js/04-object-basics/02-garbage-collection/family-no-father@2x.png
index 5ab4b3792..868c748a0 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/family-no-father@2x.png and b/1-js/04-object-basics/02-garbage-collection/family-no-father@2x.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/family.png b/1-js/04-object-basics/02-garbage-collection/family.png
index dbbc01d2f..f37464e6c 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/family.png and b/1-js/04-object-basics/02-garbage-collection/family.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/family@2x.png b/1-js/04-object-basics/02-garbage-collection/family@2x.png
index 64b4619ba..4f5d47210 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/family@2x.png and b/1-js/04-object-basics/02-garbage-collection/family@2x.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/garbage-collection-1.png b/1-js/04-object-basics/02-garbage-collection/garbage-collection-1.png
index 423191778..5cfe664c3 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/garbage-collection-1.png and b/1-js/04-object-basics/02-garbage-collection/garbage-collection-1.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/garbage-collection-1@2x.png b/1-js/04-object-basics/02-garbage-collection/garbage-collection-1@2x.png
index 223ea32a1..cf93a1605 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/garbage-collection-1@2x.png and b/1-js/04-object-basics/02-garbage-collection/garbage-collection-1@2x.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/garbage-collection-2.png b/1-js/04-object-basics/02-garbage-collection/garbage-collection-2.png
index da63d3969..2bbe4241d 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/garbage-collection-2.png and b/1-js/04-object-basics/02-garbage-collection/garbage-collection-2.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/garbage-collection-2@2x.png b/1-js/04-object-basics/02-garbage-collection/garbage-collection-2@2x.png
index 1f614e3e6..f4a7abb52 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/garbage-collection-2@2x.png and b/1-js/04-object-basics/02-garbage-collection/garbage-collection-2@2x.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/garbage-collection-3.png b/1-js/04-object-basics/02-garbage-collection/garbage-collection-3.png
index e77144c1d..665a22784 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/garbage-collection-3.png and b/1-js/04-object-basics/02-garbage-collection/garbage-collection-3.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/garbage-collection-3@2x.png b/1-js/04-object-basics/02-garbage-collection/garbage-collection-3@2x.png
index 37e349b62..60d4059cc 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/garbage-collection-3@2x.png and b/1-js/04-object-basics/02-garbage-collection/garbage-collection-3@2x.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/garbage-collection-4.png b/1-js/04-object-basics/02-garbage-collection/garbage-collection-4.png
index 110e0d9c4..4ba6e17ec 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/garbage-collection-4.png and b/1-js/04-object-basics/02-garbage-collection/garbage-collection-4.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/garbage-collection-4@2x.png b/1-js/04-object-basics/02-garbage-collection/garbage-collection-4@2x.png
index c09d75f9d..8ac09c80d 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/garbage-collection-4@2x.png and b/1-js/04-object-basics/02-garbage-collection/garbage-collection-4@2x.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/garbage-collection-5.png b/1-js/04-object-basics/02-garbage-collection/garbage-collection-5.png
index bc4ea9670..35c8816dc 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/garbage-collection-5.png and b/1-js/04-object-basics/02-garbage-collection/garbage-collection-5.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/garbage-collection-5@2x.png b/1-js/04-object-basics/02-garbage-collection/garbage-collection-5@2x.png
index 0ab697e68..4db0c1732 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/garbage-collection-5@2x.png and b/1-js/04-object-basics/02-garbage-collection/garbage-collection-5@2x.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/memory-user-john-admin.png b/1-js/04-object-basics/02-garbage-collection/memory-user-john-admin.png
index 29c4fcbea..9ddac3e29 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/memory-user-john-admin.png and b/1-js/04-object-basics/02-garbage-collection/memory-user-john-admin.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/memory-user-john-admin@2x.png b/1-js/04-object-basics/02-garbage-collection/memory-user-john-admin@2x.png
index 2f80f19a2..9069781f2 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/memory-user-john-admin@2x.png and b/1-js/04-object-basics/02-garbage-collection/memory-user-john-admin@2x.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/memory-user-john-lost.png b/1-js/04-object-basics/02-garbage-collection/memory-user-john-lost.png
index cdc1d4904..ae1684b2d 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/memory-user-john-lost.png and b/1-js/04-object-basics/02-garbage-collection/memory-user-john-lost.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/memory-user-john-lost@2x.png b/1-js/04-object-basics/02-garbage-collection/memory-user-john-lost@2x.png
index d58afdb58..c510380f9 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/memory-user-john-lost@2x.png and b/1-js/04-object-basics/02-garbage-collection/memory-user-john-lost@2x.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/memory-user-john.png b/1-js/04-object-basics/02-garbage-collection/memory-user-john.png
index 3ba5730de..2ad00b6cb 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/memory-user-john.png and b/1-js/04-object-basics/02-garbage-collection/memory-user-john.png differ
diff --git a/1-js/04-object-basics/02-garbage-collection/memory-user-john@2x.png b/1-js/04-object-basics/02-garbage-collection/memory-user-john@2x.png
index 5aa81bb0c..f365ac036 100644
Binary files a/1-js/04-object-basics/02-garbage-collection/memory-user-john@2x.png and b/1-js/04-object-basics/02-garbage-collection/memory-user-john@2x.png differ
diff --git a/1-js/04-object-basics/03-symbol/article.md b/1-js/04-object-basics/03-symbol/article.md
index 146f80b56..dae0defed 100644
--- a/1-js/04-object-basics/03-symbol/article.md
+++ b/1-js/04-object-basics/03-symbol/article.md
@@ -18,7 +18,7 @@ let id = Symbol();
 
 Possiamo fornire anche una descrizione al symbol (chiamata nome del symbol), utile per il debugging:
 
-```js
+```js run
 // id is a symbol with the description "id"
 let id = Symbol("id");
 ```
@@ -49,7 +49,14 @@ let id = Symbol("id");
 alert(id); // TypeError: Cannot convert a Symbol value to a string
 */!*
 ```
+<<<<<<< HEAD
 Se vogliamo veramente mostrare un symbol, dobbiamo utilizzare `.toString()`:
+=======
+
+That's a "language guard" against messing up, because strings and symbols are fundamentally different and should not occasionally convert one into another.
+
+If we really want to show a symbol, we need to call `.toString()` on it, like here:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ```js run
 let id = Symbol("id");
 *!*
@@ -57,7 +64,18 @@ alert(id.toString()); // Symbol(id), now it works
 */!*
 ```
 
+<<<<<<< HEAD
 Questo blocco è un "controllo di linguaggio" contro gli errori accidentali, perché le stringhe e i symbol sono fondamentalmente differenti e spesso non dovrebbe essere necessario convertirli.
+=======
+Or get `symbol.description` property to get the description only:
+```js run
+let id = Symbol("id");
+*!*
+alert(id.description); // id
+*/!*
+```
+
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ````
 
 ## Proprietà "nascoste"
diff --git a/1-js/04-object-basics/04-object-methods/7-calculator/solution.md b/1-js/04-object-basics/04-object-methods/7-calculator/solution.md
index 22c4bf187..459997624 100644
--- a/1-js/04-object-basics/04-object-methods/7-calculator/solution.md
+++ b/1-js/04-object-basics/04-object-methods/7-calculator/solution.md
@@ -1,6 +1,5 @@
 
-
-```js run demo
+```js run demo solution
 let calculator = {
   sum() {
     return this.a + this.b;
@@ -20,4 +19,3 @@ calculator.read();
 alert( calculator.sum() );
 alert( calculator.mul() );
 ```
-
diff --git a/1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md b/1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md
index b2bea5ad5..f67d562aa 100644
--- a/1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md
+++ b/1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md
@@ -1,6 +1,6 @@
 La soluzione sta nel ritornare l'oggetto stesso ad ogni chiamata.
 
-```js run
+```js run demo
 let ladder = {
   step: 0,
   up() {
@@ -28,7 +28,7 @@ ladder.up().up().down().up().down().showStep(); // 1
 
 Possiamo anche scrivere una singola chiamata per riga. Per catene molto lunghe diventa più leggibile:
 
-```js 
+```js
 ladder
   .up()
   .up()
@@ -37,4 +37,3 @@ ladder
   .down()
   .showStep(); // 1
 ```
-
diff --git a/1-js/04-object-basics/04-object-methods/8-chain-calls/task.md b/1-js/04-object-basics/04-object-methods/8-chain-calls/task.md
index 7fad53b59..d712845c2 100644
--- a/1-js/04-object-basics/04-object-methods/8-chain-calls/task.md
+++ b/1-js/04-object-basics/04-object-methods/8-chain-calls/task.md
@@ -30,7 +30,11 @@ ladder.down();
 ladder.showStep(); // 1
 ```
 
+<<<<<<< HEAD
 Modificare il codice di `up` e `down` per rendere le chiamate concatenabili, come in questo esempio:
+=======
+Modify the code of `up`, `down` and `showStep` to make the calls chainable, like this:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 ladder.up().up().down().showStep(); // 1
diff --git a/1-js/04-object-basics/04-object-methods/article.md b/1-js/04-object-basics/04-object-methods/article.md
index 609650fea..2d0f3ec41 100644
--- a/1-js/04-object-basics/04-object-methods/article.md
+++ b/1-js/04-object-basics/04-object-methods/article.md
@@ -63,7 +63,11 @@ user.sayHi(); // Hello!
 ```smart header="Programmazione orientata agli oggetti"
 Quando scriviamo codice utilizzando gli oggetti per rappresentare le entità, questa viene definita [programmazione orientata agli oggetti](https://en.wikipedia.org/wiki/Object-oriented_programming), in breve: "OOP".
 
+<<<<<<< HEAD
 OOP è una grande cosa, un ambito di interesse con i propri studi. Come scegliere le giuste entità? Come organizzare le interazioni tra loro? Questa è l'architettura di un codice, e ci sono molti libri importanti che trattano questo argomento, come "Design Patterns: Elements of Reusable Object-Oriented Software" by E.Gamma, R.Helm, R.Johnson, J.Vissides or "Object-Oriented Analysis and Design with Applications" by G.Booch. Noi cercheremo di capire i concetti chiave nel capitolo <info:object-oriented-programming>.
+=======
+OOP is a big thing, an interesting science of its own. How to choose the right entities? How to organize the interaction between them? That's architecture, and there are great books on that topic, like "Design Patterns: Elements of Reusable Object-Oriented Software" by E.Gamma, R.Helm, R.Johnson, J.Vissides or "Object-Oriented Analysis and Design with Applications" by G.Booch, and more. 
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ```
 ### La forma breve dei metodi
 
@@ -214,7 +218,11 @@ sayHi(); // undefined
 
 In questo caso `this`  è `undefined` in modalità strict. Se tentiamo di accedere a `this.name`, ci sarà un errore.
 
+<<<<<<< HEAD
 Se non è attiva la modalità strict (quindi se ci dimentichiamo `use strict`) il valor di `this` in questo sarà *l'oggetto globale* (`window` in un browser, lo studieremo più avanti). Questo strano comportamento ha delle motivazioni storiche, che `"use strict"` sistema.
+=======
+In non-strict mode the value of `this` in such case will be the *global object* (`window` in a browser, we'll get to it later in the chapter [](info:global-object)). This is a historical behavior that `"use strict"` fixes.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Va detto che solitamente una chiamata a funzione che utilizza `this` senza un oggetto non è comune, nella maggior part dei casi è un errore di programmazione. Se una funzione utilizza `this`, ha senso che venga invocata nel contesto di un oggetto.
 
@@ -257,7 +265,13 @@ Nell'ultima riga c'è un operatore ternario che deve decidere tra `user.hi` o `u
 
 Il metodo viene immediatamente chiamato con le parentesi `()`. Ma non funziona!
 
+<<<<<<< HEAD
 Questo funziona (oggetto punto metodo):
+=======
+You can see that the call results in an error, because the value of `"this"` inside the call becomes `undefined`.
+
+This works (object dot method):
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ```js
 user.hi();
 ```
diff --git a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/solution.md b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/solution.md
index e5583c5d0..86bb65416 100644
--- a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/solution.md
+++ b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/solution.md
@@ -1,5 +1,3 @@
-
-
 ```js run demo
 function Calculator() {
 
diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index 86dd89cfb..951496a27 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -226,5 +226,9 @@ JavaScript fornisce costruttori per la maggior parte degli oggetti integrati nel
 ```smart header="Oggetti, ci ritorneremo!"
 In questo capitolo abbiamo coperto solamente le basi degli oggetti e dei costruttori. Era necessario conoscerne le basi per capire meglio riguardo i data types e le funzioni che studieremo nel prossimo capitolo.
 
+<<<<<<< HEAD
 Dopo averli imparati, nel capitolo <info:object-oriented-programming> ritorneremo sugli oggetti e li copriremo più in profondità, coprendo anche i concetti di ereditarietà e classi.
+=======
+After we learn that, we return to objects and cover them in-depth in the chapters <info:prototypes> and <info:classes>.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ```
diff --git a/1-js/05-data-types/01-primitives-methods/article.md b/1-js/05-data-types/01-primitives-methods/article.md
index f1e2f8196..9208f895e 100644
--- a/1-js/05-data-types/01-primitives-methods/article.md
+++ b/1-js/05-data-types/01-primitives-methods/article.md
@@ -46,9 +46,15 @@ Questo è il paradosso contro cui si è scontato il creatore di JavaScript:
 
 La soluzione sembra un po' strana:
 
+<<<<<<< HEAD
 1. Le primitive rimangono primitive. Contengono un singolo valore.
 2. Il linguaggio consente di accedere alle proprietà e ai metodi di stringhe, numeri, booleani e symbol.
 3. Quando questo accade, viene creato uno speciale "oggetto contenitore" che fornisce le funzionalità extra, successivamente verrà distrutto.
+=======
+1. Primitives are still primitive. A single value, as desired.
+2. The language allows access to methods and properties of strings, numbers, booleans and symbols.
+3. When this happens, a special "object wrapper" that provides the extra functionality is created, and then is destroyed.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Gli "oggetti contenitore" sono diversi per ogni primitiva e sono chiamati: `String`, `Number`, `Boolean` e `Symbol`. Questi forniscono diversi insiemi di metodi.
 
diff --git a/1-js/05-data-types/02-number/8-random-min-max/solution.md b/1-js/05-data-types/02-number/8-random-min-max/solution.md
index 678cababa..2f48667b8 100644
--- a/1-js/05-data-types/02-number/8-random-min-max/solution.md
+++ b/1-js/05-data-types/02-number/8-random-min-max/solution.md
@@ -2,8 +2,13 @@ Abbiamo bisogno di far "scorrere" 'intervallo da 0..1 a `min`.. `max`.
 
 Questo può essere ottenuto con due passi:
 
+<<<<<<< HEAD
 1. Se moltiplichiamo un numero casuale compreso tra 0..1 per `max-min`, l'intervallo dei possibili valori crese da `0..1` a `0..max-min`.
 2. Ora se aggiungiamo `min`, il possibile intervallo diventa `min` - `max`.
+=======
+1. If we multiply a random number from 0..1 by `max-min`, then the interval of possible values increases `0..1` to `0..max-min`.
+2. Now if we add `min`, the possible interval becomes from `min` to `max`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 La funzione:
 
diff --git a/1-js/05-data-types/02-number/9-random-int-min-max/task.md b/1-js/05-data-types/02-number/9-random-int-min-max/task.md
index 4e595b4a5..9a8502d97 100644
--- a/1-js/05-data-types/02-number/9-random-int-min-max/task.md
+++ b/1-js/05-data-types/02-number/9-random-int-min-max/task.md
@@ -12,9 +12,9 @@ Qualsiasi numero nell'intervallo `min..max` deve poter apparire con la stessa pr
 Esempi:
 
 ```js
-alert( random(1, 5) ); // 1
-alert( random(1, 5) ); // 3
-alert( random(1, 5) ); // 5
+alert( randomInteger(1, 5) ); // 1
+alert( randomInteger(1, 5) ); // 3
+alert( randomInteger(1, 5) ); // 5
 ```
 
 Potete utilizzare la soluzione dell'[esercizio precedente](info:task/random-min-max) come base.
diff --git a/1-js/05-data-types/02-number/article.md b/1-js/05-data-types/02-number/article.md
index a586ae06d..0af92d8c5 100644
--- a/1-js/05-data-types/02-number/article.md
+++ b/1-js/05-data-types/02-number/article.md
@@ -26,11 +26,15 @@ In altre parole, `"e"` moltiplica il numero `1` seguito dal numero di zeri dati.
 
 ```js
 1e3 = 1 * 1000
-1.23e6 = 1.23 * 1000000 
+1.23e6 = 1.23 * 1000000
 ```
 
 
+<<<<<<< HEAD
 Ora proviamo a scrivere qualcosa di molto piccolo. Ad esempio, 1 microsecondo (un milionesimo di secondo): 
+=======
+Now let's write something very small. Say, 1 microsecond (one millionth of a second):
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 let ms = 0.000001;
@@ -39,7 +43,7 @@ let ms = 0.000001;
 Come prima, l'utilizzo di `"e"` può aiutare. Se volessimo evitare di scrivere esplicitamente tutti gli "0", potremmo scrivere:
 
 ```js
-let ms = 1e-6; // six zeroes to the left from 1 
+let ms = 1e-6; // six zeroes to the left from 1
 ```
 
 Se contiamo gli zeri in `0.000001`, ce ne sono 6. Quindi ovviamente `1e-6`.  
@@ -152,8 +156,13 @@ Ci sono due modi per farlo:
     alert( Math.floor(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23
     ```
 
+<<<<<<< HEAD
 2. Il metodo [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) arrotonda il numero a `n` cifre dopo la virgola e ritorna una rappresentazione in stringa del risultato.
         
+=======
+2. The method [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) rounds the number to `n` digits after the point and returns a string representation of the result.
+
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
     ```js run
     let num = 12.34;
     alert( num.toFixed(1) ); // "12.3"
@@ -170,7 +179,7 @@ Ci sono due modi per farlo:
 
     ```js run
     let num = 12.34;
-    alert( num.toFixed(5) ); // "12.34000", added zeroes to make exactly 5 digits 
+    alert( num.toFixed(5) ); // "12.34000", added zeroes to make exactly 5 digits
     ```
 
     Possiamo convertire il risultato al tipo numerico utilizzando la somma unaria o chiamando il metodo `Number()`: `+num.toFixed(5)`.
@@ -182,7 +191,7 @@ Internamente, un numero è rappresentato in formato 64-bit [IEEE-754](http://en.
 Se un numero è troppo grande, tale da superare i 64 bit disponibili, come ad esempio un numero potenzialmente infinito:
 
 ```js run
-alert( 1e500 ); // Infinity 
+alert( 1e500 ); // Infinity
 ```
 
 Potrebbe essere poco ovvio, ma quello che accade è la perdita di precisione.
@@ -193,7 +202,11 @@ Consideriamo questo test (falso!):
 alert( 0.1 + 0.2 == 0.3 ); // *!*false*/!*
 ```
 
+<<<<<<< HEAD
 Esatto, se proviamo a confrontare il risultato della somma tra `0.1` e `0.2` con `0.3`, otteniamo `false`. 
+=======
+That's right, if we check whether the sum of `0.1` and `0.2` is `0.3`, we get `false`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Strano! Quale può essere il risultato se non `0.3`?
 
@@ -207,7 +220,11 @@ Ma perché accade questo?
 
 Un numero viene memorizzato nella sua forma binaria, una sequenza di "1" e "0". I numeri con virgola come `0.1`, `0.2` che visti nella loro forma decimale sembrano semplici, sono in realtà una sequenza infinita di cifre nella forma binaria.
 
+<<<<<<< HEAD
 In altre parole, cos'è `0.1`? Vale 1 diviso 10 `1/10`, "un decimo". Nel sistema decimale questi numeri sono facilmente rappresentabili. Prendiamo invece "un terzo": `1/3`. Diventa un numero con infiniti decimali `0.33333(3)`. 
+=======
+In other words, what is `0.1`? It is one divided by ten `1/10`, one-tenth. In decimal numeral system such numbers are easily representable. Compare it to one-third: `1/3`. It becomes an endless fraction `0.33333(3)`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Quindi, le divisioni per potenze di `10` funzionano molto bene nel sistema decimale, non vale lo stesso con la divisione per `3`. Per la stessa ragione, nel sistema binario le divisioni per potenze di `2` sono una garanzia, ma `1/10` diventa una sequenza infinita di cifre.
 
@@ -227,40 +244,62 @@ Questo è il motivo per cui `0.1 + 0.2` non vale esattamente `0.3`.
 ```smart header="Non solo JavaScript"
 Lo stesso problema esiste in molti altri linguaggi di programmazione.
 
+<<<<<<< HEAD
 PHP, Java, C, Perl, Ruby hanno lo stesso tipo di problema, poiché si basano sullo stesso formato numerico. 
 ```
 
 Possiamo risolvere questo problema? Certamente, ci sono diverse soluzioni:
 
 1. Possiamo arrotondare il risultato con un metodo [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed):
+=======
+PHP, Java, C, Perl, Ruby give exactly the same result, because they are based on the same numeric format.
+```
 
-    ```js run
-    let sum = 0.1 + 0.2;
-    alert( sum.toFixed(2) ); // 0.30
-    ```
+Can we work around the problem? Sure, the most reliable method is to round the result with the help of a method [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed):
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
+```js run
+let sum = 0.1 + 0.2;
+alert( sum.toFixed(2) ); // 0.30
+```
+
+<<<<<<< HEAD
     Da notare che `toFixed` ritorna sempre una stringa. Viene cosi garantito che ci siano almeno due cifre dopo la virgola decimale. Questo ci torna molto utile se abbiamo un e-shopping e vogliamo mostrare `$0.30`. Per tutti gli altri casi possiamo semplicemente chiamare la conversione con l'operatore di somma unaria:
+=======
+Please note that `toFixed` always returns a string. It ensures that it has 2 digits after the decimal point. That's actually convenient if we have an e-shopping and need to show `$0.30`. For other cases, we can use the unary plus to coerce it into a number:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
-    ```js run
-    let sum = 0.1 + 0.2;
-    alert( +sum.toFixed(2) ); // 0.3
-    ```
+```js run
+let sum = 0.1 + 0.2;
+alert( +sum.toFixed(2) ); // 0.3
+```
 
+<<<<<<< HEAD
 2. Possiamo temporaneamente convertire i numeri ad interi per eseguire le operazioni e poi riconvertirli. In questo modo:
+=======
+We also can temporarily multiply the numbers by 100 (or a bigger number) to turn them into integers, do the maths, and then divide back. Then, as we're doing maths with integers, the error somewhat decreases, but we still get it on division:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
-    ```js run
-    alert( (0.1 * 10 + 0.2 * 10) / 10 ); // 0.3
-    ```
+```js run
+alert( (0.1 * 10 + 0.2 * 10) / 10 ); // 0.3
+alert( (0.28 * 100 + 0.14 * 100) / 100); // 0.4200000000000001
+```
 
+<<<<<<< HEAD
     Questo funziona perché quando facciamo `0.1 * 10 = 1` e `0.2 * 10 = 2` entrambi diventano interi, non vi è quindi perdita di precisione. 
 
 3. Se abbiamo a che fare con dei prezzi, la miglior soluzione rimane quella di memorizzare tutti i prezzi in centesimi, evitando quindi di utilizzare i numeri con virgola. Ma cosa succede se proviamo ad applicare uno sconto del 30%? Nella pratica, evadere completamente questo problema è difficile, in alcuni casi possono tornare utili entrambe le soluzioni spiegate sopra.
+=======
+So, multiply/divide approach reduces the error, but doesn't remove it totally.
+
+Sometimes we could try to evade fractions at all. Like if we're dealing with a shop, then we can store prices in cents instead of dollars. But what if we apply a discount of 30%? In practice, totally evading fractions is rarely possible. Just round them to cut "tails" when needed.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ````smart header="La cosa divertente"
 Provate ad eseguire questo:
 
 ```js run
-// Hello! I'm a self-increasing number! 
+// Hello! I'm a self-increasing number!
 alert( 9999999999999999 ); // shows 10000000000000000
 ```
 
@@ -272,7 +311,11 @@ JavaScript non mostra errori in questi casi. Semplicemente fa del suo meglio per
 ```smart header="Due zeri"
 Un'altra conseguenza divertente della rappresentazione interna è l'esistenza di due zeri: `0` e `-0`.
 
+<<<<<<< HEAD
 Questo perché il segno viene rappresentato con un solo bit, in questo modo ogni numero può essere positivo o negativo, lo stesso vale per lo zero.
+=======
+That's because a sign is represented by a single bit, so every number can be positive or negative, including a zero.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Nella maggior parte dei casi questa differenza è impercettibile, poiché gli operatori sono studiati per trattarli allo stesso modo.
 ```
@@ -326,10 +369,17 @@ Da notare che una stringa vuota o contenente solo spazi viene trattata come `0`
 
 Esiste uno speciale metodo integrato [Object.is](mdn:js/Object/is) che confronta valori proprio come `===`, ma risulta molto più affidabile in due casi limite:
 
+<<<<<<< HEAD
 1. Funziona con `NaN`: `Object.is(NaN, NaN) === true`, e questo è un bene. 
 2. I valori `0` e `-0` sono diversi: `Object.is(0, -0) === false`, raramente ha importanza, ma questi due valori sono comunque differenti.
 
 In tutti gli altri casi, `Object.is(a, b)` equivale a `a === b`. 
+=======
+1. It works with `NaN`: `Object.is(NaN, NaN) === true`, that's a good thing.
+2. Values `0` and `-0` are different: `Object.is(0, -0) === false`, it rarely matters, but these values technically are different.
+
+In all other cases, `Object.is(a, b)` is the same as `a === b`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Questo metodo di confronto viene spesso utilizzato in JavaScript. Quando un algoritmo interno ha necessità di verificare che due valori siano esattamente la stessa cosa, si utilizza `Object.is` (internamente chiamato [SameValue](https://tc39.github.io/ecma262/#sec-samevalue)).
 ```
@@ -424,7 +474,11 @@ Per diversi sistemi numerici:
 
 Per convertire a numeri valori del tipo `12pt` e `100px`:
 
+<<<<<<< HEAD
 - Usate `parseInt/parseFloat` per una conversione "leggera", che legge numeri da una stringa e ritorna il valore che è riuscito a leggere prima dell'errore. 
+=======
+- Use `parseInt/parseFloat` for the "soft" conversion, which reads a number from a string and then returns the value they could read before the error.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Per i numeri con la virgola:
 
@@ -433,6 +487,10 @@ Per i numeri con la virgola:
 
 Altre funzioni matematiche:
 
+<<<<<<< HEAD
 - Guardate l'oggetto [Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math) in caso di necessità. La libreria non è molto ampia, ma è in grado di coprire le necessità di base.
 
 
+=======
+- See the [Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math) object when you need them. The library is very small, but can cover basic needs.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/05-data-types/03-string/2-check-spam/solution.md b/1-js/05-data-types/03-string/2-check-spam/solution.md
index c9f4baa37..63960025d 100644
--- a/1-js/05-data-types/03-string/2-check-spam/solution.md
+++ b/1-js/05-data-types/03-string/2-check-spam/solution.md
@@ -1,4 +1,8 @@
+<<<<<<< HEAD
 Per far si che la ricerca non si preoccupi del timbro delle lettere, portiamo l'intera stringa a lettere minuscole e poi eseguiamo la ricerca:
+=======
+To make the search case-insensitive, let's bring the string to lower case and then search:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 function checkSpam(str) {
diff --git a/1-js/05-data-types/03-string/3-truncate/solution.md b/1-js/05-data-types/03-string/3-truncate/solution.md
index c7a2cb3ac..8de97cff2 100644
--- a/1-js/05-data-types/03-string/3-truncate/solution.md
+++ b/1-js/05-data-types/03-string/3-truncate/solution.md
@@ -2,10 +2,9 @@ La lunghezza massima deve essere `maxlength`, quindi abbiamo bisgnono di troncar
 
 Da notare che esiste un codice che identifica il simbolo "...". Quindi non vengono contati come tre punti.
 
-```js run
+```js run demo
 function truncate(str, maxlength) {
-  return (str.length > maxlength) ? 
+  return (str.length > maxlength) ?
     str.slice(0, maxlength - 1) + '…' : str;
 }
 ```
-
diff --git a/1-js/05-data-types/03-string/4-extract-currency/solution.md b/1-js/05-data-types/03-string/4-extract-currency/solution.md
index 8b1378917..e69de29bb 100644
--- a/1-js/05-data-types/03-string/4-extract-currency/solution.md
+++ b/1-js/05-data-types/03-string/4-extract-currency/solution.md
@@ -1 +0,0 @@
-
diff --git a/1-js/05-data-types/03-string/article.md b/1-js/05-data-types/03-string/article.md
index 557412444..37a5ea364 100644
--- a/1-js/05-data-types/03-string/article.md
+++ b/1-js/05-data-types/03-string/article.md
@@ -548,8 +548,13 @@ Questo metodo in realtà ha due argomenti opzionali specificati nella [documenta
 
 ## Internamente, Unicode
 
+<<<<<<< HEAD
 ```warn header="Apprendimento avanzato"
 Questa sezione andrà più in profondità riguardo le stringhe. Quello che leggerai ti potrà essere utile se hai intenzione di utilizzare emoji, simboli matematici o geroglifici.
+=======
+```warn header="Advanced knowledge"
+The section goes deeper into string internals. This knowledge will be useful for you if you plan to deal with emoji, rare mathematical or hieroglyphic characters or other rare symbols.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Puoi semplicemente saltare questa sezione se non hai in programma di utilizzarle.
 ```
diff --git a/1-js/05-data-types/04-array/10-maximal-subarray/solution.md b/1-js/05-data-types/04-array/10-maximal-subarray/solution.md
index 0ac86d17e..0ba80f14d 100644
--- a/1-js/05-data-types/04-array/10-maximal-subarray/solution.md
+++ b/1-js/05-data-types/04-array/10-maximal-subarray/solution.md
@@ -1,4 +1,8 @@
+<<<<<<< HEAD
 # La soluzione lenta
+=======
+# Slow solution
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Possiamo calcoalre tutte le somme possibili.
 
@@ -29,8 +33,8 @@ Ad esempio, per `[-1, 2, 3, -9, 11]`:
 -9
 -9 + 11
 
-// Starting from -11
--11
+// Starting from 11
+11
 ```
 
 Il codice è un ciclo annidato: il ciclo esterno cicla tutti gli elementi dell'array, quello interno esegue le somme a partire dall'elemento corrente.
@@ -59,7 +63,11 @@ alert( getMaxSubSum([100, -9, 2, -3, 5]) ); // 100
 
 La soluzione ha una complessità di [O(n<sup>2</sup>)](https://en.wikipedia.org/wiki/Big_O_notation). In altre parole, se l'array fosse 2 volte più grande, l'algoritmo lavorerebbe 4 volte più lentamente.
 
+<<<<<<< HEAD
 Per grandi array (1000, 10000 o più elementi) questi algoritmi possono portare ad enormi attese.
+=======
+For big arrays (1000, 10000 or more items) such algorithms can lead to a serious sluggishness.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 # Soluzione performante
 
@@ -67,7 +75,7 @@ Iniziamo ad esaminare l'array mantenendo la somma parizale degli elementi nella
 
 Se la risposta vi sembra troppo vaga, date un'occhiata al codice:
 
-```js run
+```js run demo
 function getMaxSubSum(arr) {
   let maxSum = 0;
   let partialSum = 0;
diff --git a/1-js/05-data-types/04-array/2-create-array/solution.md b/1-js/05-data-types/04-array/2-create-array/solution.md
index eec9055e7..f032b55f0 100644
--- a/1-js/05-data-types/04-array/2-create-array/solution.md
+++ b/1-js/05-data-types/04-array/2-create-array/solution.md
@@ -5,6 +5,6 @@ let styles = ["Jazz", "Blues"];
 styles.push("Rock-n-Roll");
 styles[Math.floor((styles.length - 1) / 2)] = "Classics";
 alert( styles.shift() );
-styles.unshift("Rap", "Reggie");
+styles.unshift("Rap", "Reggae");
 ```
 
diff --git a/1-js/05-data-types/04-array/array-pop.png b/1-js/05-data-types/04-array/array-pop.png
index 9113c76be..4d6867b14 100644
Binary files a/1-js/05-data-types/04-array/array-pop.png and b/1-js/05-data-types/04-array/array-pop.png differ
diff --git a/1-js/05-data-types/04-array/array-pop@2x.png b/1-js/05-data-types/04-array/array-pop@2x.png
index e6ec8d8fb..c65ef9446 100644
Binary files a/1-js/05-data-types/04-array/array-pop@2x.png and b/1-js/05-data-types/04-array/array-pop@2x.png differ
diff --git a/1-js/05-data-types/04-array/array-shift.png b/1-js/05-data-types/04-array/array-shift.png
index 03b29d930..5798a6476 100644
Binary files a/1-js/05-data-types/04-array/array-shift.png and b/1-js/05-data-types/04-array/array-shift.png differ
diff --git a/1-js/05-data-types/04-array/array-shift@2x.png b/1-js/05-data-types/04-array/array-shift@2x.png
index c9888a44c..ba95f2651 100644
Binary files a/1-js/05-data-types/04-array/array-shift@2x.png and b/1-js/05-data-types/04-array/array-shift@2x.png differ
diff --git a/1-js/05-data-types/04-array/array-speed.png b/1-js/05-data-types/04-array/array-speed.png
index 3737e8248..a400d0c1d 100644
Binary files a/1-js/05-data-types/04-array/array-speed.png and b/1-js/05-data-types/04-array/array-speed.png differ
diff --git a/1-js/05-data-types/04-array/array-speed@2x.png b/1-js/05-data-types/04-array/array-speed@2x.png
index e45624b50..11a3e67c9 100644
Binary files a/1-js/05-data-types/04-array/array-speed@2x.png and b/1-js/05-data-types/04-array/array-speed@2x.png differ
diff --git a/1-js/05-data-types/04-array/article.md b/1-js/05-data-types/04-array/article.md
index 49fcd554a..22b9137c7 100644
--- a/1-js/05-data-types/04-array/article.md
+++ b/1-js/05-data-types/04-array/article.md
@@ -104,7 +104,11 @@ Una [queue](https://en.wikipedia.org/wiki/Queue_(abstract_data_type)) (coda) è
 
 Gli array supportano entrambre le operazioni.
 
+<<<<<<< HEAD
 Nella pratica non è strano incontrare questo "tipo" di array. Ad esempiom una coda di messaggi che devono essere mostrati a schermo.
+=======
+In practice we need it very often. For example, a queue of messages that need to be shown on-screen.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Esiste un altro caso d'uso degli array -- la struttrura dati chiamata [stack](https://en.wikipedia.org/wiki/Stack_(abstract_data_type)). 
 
@@ -319,7 +323,11 @@ Non è comunque un ottima idea. Si possono verificare diversi errori:
 
     Ci sono anche degli oggetti chiamati "array-like" (simili ad array) nei browser e in altri ambienti, che *assomigliano ad array*. Infatti come proprietà possiedono `length` e degli indici, ma allo stesso tempo contengono proprietà e metodi di tipo non numerico, di cui solitamente non abbiamo bisogno. Il ciclo `for..in` li passerà tutti. Quindi se stiamo utilizzando degli oggetti array-like, questi "extra" potrebbero rivelarsi un problema.
 
+<<<<<<< HEAD
 2. Il ciclo `for..in` è ottimizzato per oggetti generici, non array, può risultare quindi 10-100 volte più lento. Ovviamente rimane comunque un operazione molto veloce. Può essere un problema solo in caso si verifichino ingorghi. 
+=======
+2. The `for..in` loop is optimized for generic objects, not arrays, and thus is 10-100 times slower. Of course, it's still very fast. The speedup may only matter in bottlenecks or seem irrelevant. But still we should be aware of the difference.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Generalmente, non dovremmo utilizzare `for..in` per array.
 
diff --git a/1-js/05-data-types/04-array/queue.png b/1-js/05-data-types/04-array/queue.png
index 5e1fb640c..39af3beda 100644
Binary files a/1-js/05-data-types/04-array/queue.png and b/1-js/05-data-types/04-array/queue.png differ
diff --git a/1-js/05-data-types/04-array/queue@2x.png b/1-js/05-data-types/04-array/queue@2x.png
index 6acfc83d1..75045a51d 100644
Binary files a/1-js/05-data-types/04-array/queue@2x.png and b/1-js/05-data-types/04-array/queue@2x.png differ
diff --git a/1-js/05-data-types/04-array/stack.png b/1-js/05-data-types/04-array/stack.png
index d1c9cb9af..7d2599355 100644
Binary files a/1-js/05-data-types/04-array/stack.png and b/1-js/05-data-types/04-array/stack.png differ
diff --git a/1-js/05-data-types/04-array/stack@2x.png b/1-js/05-data-types/04-array/stack@2x.png
index b3835fa44..16c622518 100644
Binary files a/1-js/05-data-types/04-array/stack@2x.png and b/1-js/05-data-types/04-array/stack@2x.png differ
diff --git a/1-js/05-data-types/05-array-methods/1-camelcase/_js.view/solution.js b/1-js/05-data-types/05-array-methods/1-camelcase/_js.view/solution.js
index 024d6d6c2..490f570ad 100644
--- a/1-js/05-data-types/05-array-methods/1-camelcase/_js.view/solution.js
+++ b/1-js/05-data-types/05-array-methods/1-camelcase/_js.view/solution.js
@@ -1,8 +1,10 @@
 function camelize(str) {
   return str
-    .split('-') // my-long-word -> ['my', 'long', 'word']
-    .map( 
+    .split('-') // splits 'my-long-word' into array ['my', 'long', 'word']
+    .map(
+      // capitalizes first letters of all array items except the first one
+      // converts ['my', 'long', 'word'] into ['my', 'Long', 'Word']
       (word, index) => index == 0 ? word : word[0].toUpperCase() + word.slice(1)
-    ) // ['my', 'long', 'word'] -> ['my', 'Long', 'Word']
-    .join(''); // ['my', 'Long', 'Word'] -> myLongWord
+    )
+    .join(''); // joins ['my', 'Long', 'Word'] into 'myLongWord'
 }
diff --git a/1-js/05-data-types/05-array-methods/11-array-unique/solution.md b/1-js/05-data-types/05-array-methods/11-array-unique/solution.md
index 247d96423..5179d52f0 100644
--- a/1-js/05-data-types/05-array-methods/11-array-unique/solution.md
+++ b/1-js/05-data-types/05-array-methods/11-array-unique/solution.md
@@ -2,7 +2,7 @@ Attraversiamo gli elementi dell'array:
 - Per ogni elemento controlliamo se l'array risultante già lo contiene.
 - Se lo troviamo, passiamo al prossimo, altrimenti lo aggiungiamo.
 
-```js run
+```js run demo
 function unique(arr) {
   let result = [];
 
diff --git a/1-js/05-data-types/05-array-methods/2-filter-range/solution.md b/1-js/05-data-types/05-array-methods/2-filter-range/solution.md
index e69de29bb..73993a07a 100644
--- a/1-js/05-data-types/05-array-methods/2-filter-range/solution.md
+++ b/1-js/05-data-types/05-array-methods/2-filter-range/solution.md
@@ -0,0 +1,14 @@
+```js run demo
+function filterRange(arr, a, b) {
+  // added brackets around the expression for better readability
+  return arr.filter(item => (a <= item && item <= b));
+}
+
+let arr = [5, 3, 8, 1];
+
+let filtered = filterRange(arr, 1, 4);
+
+alert( filtered ); // 3,1 (matching values)
+
+alert( arr ); // 5,3,8,1 (not modified)
+```
diff --git a/1-js/05-data-types/05-array-methods/3-filter-range-in-place/_js.view/solution.js b/1-js/05-data-types/05-array-methods/3-filter-range-in-place/_js.view/solution.js
index 61cda126b..488db3755 100644
--- a/1-js/05-data-types/05-array-methods/3-filter-range-in-place/_js.view/solution.js
+++ b/1-js/05-data-types/05-array-methods/3-filter-range-in-place/_js.view/solution.js
@@ -1,5 +1,4 @@
 
-
 function filterRangeInPlace(arr, a, b) {
 
   for (let i = 0; i < arr.length; i++) {
@@ -12,4 +11,4 @@ function filterRangeInPlace(arr, a, b) {
     }
   }
 
-}
\ No newline at end of file
+}
diff --git a/1-js/05-data-types/05-array-methods/3-filter-range-in-place/solution.md b/1-js/05-data-types/05-array-methods/3-filter-range-in-place/solution.md
index e69de29bb..36e3130ff 100644
--- a/1-js/05-data-types/05-array-methods/3-filter-range-in-place/solution.md
+++ b/1-js/05-data-types/05-array-methods/3-filter-range-in-place/solution.md
@@ -0,0 +1,21 @@
+```js run demo
+function filterRangeInPlace(arr, a, b) {
+
+  for (let i = 0; i < arr.length; i++) {
+    let val = arr[i];
+
+    // remove if outside of the interval
+    if (val < a || val > b) {
+      arr.splice(i, 1);
+      i--;
+    }
+  }
+
+}
+
+let arr = [5, 3, 8, 1];
+
+filterRangeInPlace(arr, 1, 4); // removed the numbers except from 1 to 4
+
+alert( arr ); // [3, 1]
+```
diff --git a/1-js/05-data-types/05-array-methods/8-sort-objects/solution.md b/1-js/05-data-types/05-array-methods/8-sort-objects/solution.md
index 8d56db9d6..9f1ade707 100644
--- a/1-js/05-data-types/05-array-methods/8-sort-objects/solution.md
+++ b/1-js/05-data-types/05-array-methods/8-sort-objects/solution.md
@@ -1,17 +1,18 @@
 ```js run no-beautify
-function sortByName(arr) {
-  arr.sort((a, b) => a.name > b.name);
+function sortByAge(arr) {
+  arr.sort((a, b) => a.age > b.age ? 1 : -1);
 }
 
 let john = { name: "John", age: 25 };
 let pete = { name: "Pete", age: 30 };
 let mary = { name: "Mary", age: 28 };
 
-let arr = [ john, pete, mary ];
+let arr = [ pete, john, mary ];
 
-sortByName(arr);
+sortByAge(arr);
 
 // now sorted is: [john, mary, pete]
+alert(arr[0].name); // John
 alert(arr[1].name); // Mary
+alert(arr[2].name); // Pete
 ```
-
diff --git a/1-js/05-data-types/05-array-methods/8-sort-objects/task.md b/1-js/05-data-types/05-array-methods/8-sort-objects/task.md
index 74e232482..dd1569133 100644
--- a/1-js/05-data-types/05-array-methods/8-sort-objects/task.md
+++ b/1-js/05-data-types/05-array-methods/8-sort-objects/task.md
@@ -2,9 +2,15 @@ importance: 5
 
 ---
 
+<<<<<<< HEAD
 # Riordinare oggetti
 
 Scrivete una funzione `sortByName(users)` che prenda un array di oggetti con proprietà `name` e lo riordini.
+=======
+# Sort users by age
+
+Write the function `sortByAge(users)` that gets an array of objects with the `age` property and sorts them by `age`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -13,11 +19,12 @@ let john = { name: "John", age: 25 };
 let pete = { name: "Pete", age: 30 };
 let mary = { name: "Mary", age: 28 };
 
-let arr = [ john, pete, mary ];
+let arr = [ pete, john, mary ];
 
-sortByName(arr);
+sortByAge(arr);
 
 // now: [john, mary, pete]
+alert(arr[0].name); // John
 alert(arr[1].name); // Mary
+alert(arr[2].name); // Pete
 ```
-
diff --git a/1-js/05-data-types/05-array-methods/article.md b/1-js/05-data-types/05-array-methods/article.md
index 549fc5696..f1d05535a 100644
--- a/1-js/05-data-types/05-array-methods/article.md
+++ b/1-js/05-data-types/05-array-methods/article.md
@@ -122,7 +122,11 @@ La sintassi è:
 arr.slice(start, end)
 ```
 
+<<<<<<< HEAD
 Ritorna un nuovo array contente tutti gli elementi a partire da `"start"` fino ad `"end"` (`"end"` esclusa). Sia `start` che `end` possono essere negativi, in tal caso si inizierà a contare dalla coda dell'array.
+=======
+It returns a new array containing all items from index `"start"` to `"end"` (not including `"end"`). Both `start` and `end` can be negative, in that case position from array end is assumed.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Funziona come `str.slice`, ma crea dei sotto-array piuttosto che sotto-stringhe.
 
@@ -201,7 +205,40 @@ let arrayLike = {
 alert( arr.concat(arrayLike) ); // 1,2,something,else
 ```
 
+<<<<<<< HEAD
 ## Ricerca in array
+=======
+## Iterate: forEach
+
+The [arr.forEach](mdn:js/Array/forEach) method allows to run a function for every element of the array.
+
+The syntax:
+```js
+arr.forEach(function(item, index, array) {
+  // ... do something with item
+});
+```
+
+For instance, this shows each element of the array:
+
+```js run
+// for each element call alert
+["Bilbo", "Gandalf", "Nazgul"].forEach(alert);
+```
+
+And this code is more elaborate about their positions in the target array:
+
+```js run
+["Bilbo", "Gandalf", "Nazgul"].forEach((item, index, array) => {
+  alert(`${item} is at index ${index} in ${array}`);
+});
+```
+
+The result of the function (if it returns any) is thrown away and ignored.
+
+
+## Searching in array
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ora vedremo dei metodi per effettuare ricerche in un array.
 
@@ -246,7 +283,8 @@ In questi casi si utilizza il metodo [arr.find](mdn:js/Array/find).
 La sintassi è:
 ```js
 let result = arr.find(function(item, index, array) {
-  // should return true if the item is what we are looking for
+  // if true is returned, item is returned and iteration is stopped
+  // for falsy scenario returns undefined
 });
 ```
 
@@ -274,9 +312,15 @@ alert(user.name); // John
 
 Nella realtà gli array di oggetti sono una cosa molto comune, quindi il metodo `find` risulta molto utile.
 
+<<<<<<< HEAD
 Da notare che nell'esempio noi forniamo a `find` un singolo argomento `item => item.id == 1`. Gli altri parametri di `find` sono raramente utilizzati.
 
 Il metodo [arr.findIndex](mdn:js/Array/findIndex) fa essenzialmente la stessa cosa, semplicemente ritorna l'indice in cui è stata trovata la corrispondenza piuttosto di ritornare l'oggetto stesso.
+=======
+Note that in the example we provide to `find` the function `item => item.id == 1` with one argument. Other arguments of this function are rarely used.
+
+The [arr.findIndex](mdn:js/Array/findIndex) method is essentially the same, but it returns the index where the element was found instead of the element itself and `-1` is returned when nothing is found.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ### filter
 
@@ -284,11 +328,16 @@ Il metodo `find` cerca un singola occorrenza dell'elemento (la prima) e ritorna
 
 Se vogliamo cercare più occorrenze, possiamo utilizzare [arr.filter(fn)](mdn:js/Array/filter).
 
+<<<<<<< HEAD
 La sintassi è pressoché la stessa di `find`, ma ritorna un array contenente tutte le corrispondenze trovate:
+=======
+The syntax is similar to `find`, but filter continues to iterate for all array elements even if `true` is already returned:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 let results = arr.filter(function(item, index, array) {
-  // should return true if the item passes the filter
+  // if true item is pushed to results and iteration continues
+  // returns empty array for complete falsy scenario
 });
 ```
 
@@ -328,7 +377,7 @@ La funzione viene chiamata per ogni elemento dell'array e ritorna un array di ri
 Ad esempio, qui trasformiamo ogni elemento nella sua lunghezza:
 
 ```js run
-let lengths = ["Bilbo", "Gandalf", "Nazgul"].map(item => item.length)
+let lengths = ["Bilbo", "Gandalf", "Nazgul"].map(item => item.length);
 alert(lengths); // 5,7,6
 ```
 
@@ -476,7 +525,11 @@ alert( str.split('') ); // t,e,s,t
 ```
 ````
 
+<<<<<<< HEAD
 La chiamata [arr.join(str)](mdn:js/Array/join) fa esattamente l'inverso di `split`. Crea una stringa con gli elementi di `arr` divisi da un carattere di tipo stringa `str`.
+=======
+The call [arr.join(separator)](mdn:js/Array/join) does the reverse to `split`. It creates a string of `arr` items glued by `separator` between them.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
@@ -491,23 +544,35 @@ alert( str ); // Bilbo;Gandalf;Nazgul
 ### reduce/reduceRight
 Quando vogliamo iterare su un array -- possiamo utilizzare `forEach`.
 
+<<<<<<< HEAD
 Quando invece abbiamo la necessità di iterare e ritornare dati per ogni elemento -- possiamo usare `map`.
+=======
+When we need to iterate over an array -- we can use `forEach`, `for` or `for..of`.
+
+When we need to iterate and return the data for each element -- we can use `map`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 I metodi [arr.reduce](mdn:js/Array/reduce) e [arr.reduceRight](mdn:js/Array/reduceRight) fanno parte della stessa categoria, ma sono leggermente più complessi. Vengono utilizzati per calcolare un singolo valore basato sul contenuto dell'array.
 
 La sintassi è:
 
 ```js
-let value = arr.reduce(function(previousValue, item, index, arr) {
+let value = arr.reduce(function(previousValue, item, index, array) {
   // ...
 }, initial);
 ```
 
 La funzione viene applicata agli elementi. Potrete notare che fra gli argomenti ce ne sono alcuni di familiari, a partire dal secondo:
 
+<<<<<<< HEAD
 - `item` -- è l'elemento corrente.
 - `index` -- è la sua posizione.
 - `arr` -- è l'array.
+=======
+- `item` -- is the current array item.
+- `index` -- is its position.
+- `array` -- is the array.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Finora, è uguale a `forEach/map`. Ma c'è un ulteriore argomento:
 
@@ -537,7 +602,11 @@ Il flusso di calcolo:
 
 ![](reduce.png)
 
+<<<<<<< HEAD
 O nella forma tabellare, in cui ogni riga rappresenta una chiamata di funzione:
+=======
+Or in the form of a table, where each row represents a function call on the next array element:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 |   |`sum`|`current`|`result`|
 |---|-----|---------|---------|
@@ -583,6 +652,7 @@ Quindi è fortemente consigliato di specificare sempre un valore iniziale.
 Il metodo [arr.reduceRight](mdn:js/Array/reduceRight) fa esattamente la stessa cosa, ma da destra verso sinistra.
 
 
+<<<<<<< HEAD
 ## Iterate: forEach
 
 Il metodo [arr.forEach](mdn:js/Array/forEach) consente di eseguire una funzione per ogni elemento dell'array.
@@ -611,6 +681,8 @@ Questo codice è più elaborato e mostra anche la posizione:
 
 Il risultato della funzione (sempre se ritorna qualcosa) viene ignorato.
 
+=======
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ## Array.isArray
 
 Gli array non utilizzano una sintassi differente. Sono comunque basati sugli oggetti.
@@ -687,11 +759,22 @@ Un breve riepilogo dei metodi per array:
   - `slice(start, end)` -- crea un nuovo array, e copia al suo interno gli elementi da `start` fino ad `end` (esclusa).
   - `concat(...items)` -- ritorna un nuovo array: copia tutti gli elementi di quello corrente e ci aggiunge `items`. Se uno degli `items` è un array, allora vengono presi anche i suoi elementi.
 
+<<<<<<< HEAD
 - Ricercare elementi:
   - `indexOf/lastIndexOf(item, pos)` -- cerca `item` a partire da `pos`, e ritorna l'indice, oppure `-1` se non lo trova.
   - `includes(value)` -- ritorna `true` se l'array contiene `value`, altrimenti `false`.
   - `find/filter(func)` -- filtra gli elementi tramite la funzione, ritorna il primo/tutti i valori che ritornano `true`.
   - `findIndex` è simile a `find`, ma ritorna l'indice piuttosto del valore.
+=======
+- To search among elements:
+  - `indexOf/lastIndexOf(item, pos)` -- look for `item` starting from position `pos`, return the index or `-1` if not found.
+  - `includes(value)` -- returns `true` if the array has `value`, otherwise `false`.
+  - `find/filter(func)` -- filter elements through the function, return first/all values that make it return `true`.
+  - `findIndex` is like `find`, but returns the index instead of a value.
+  
+- To iterate over elements:
+  - `forEach(func)` -- calls `func` for every element, does not return anything.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 - Per modificare un array:
   - `map(func)` -- crea un nuovo array con i risultati della chiamata `func` su tutti i suoi elementi.
@@ -700,11 +783,16 @@ Un breve riepilogo dei metodi per array:
   - `split/join` -- converte una stringa in array e vice versa.
   - `reduce(func, initial)` -- calculate a single value over the array by calling `func` for each element and passing an intermediate result between the calls.
 
+<<<<<<< HEAD
 - Per iterare sugli elementi:
   - `forEach(func)` -- chiama `func` su ogni elemento, ma non ritorna nulla.
 
 - Un altro metodo utile:
   - `Array.isArray(arr)` controlla se `arr` è un array.
+=======
+- Additionally:
+  - `Array.isArray(arr)` checks `arr` for being an array.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Da notare che i metodi `sort`, `reverse` e `splice` modificano l'array stesso.
 
diff --git a/1-js/05-data-types/05-array-methods/reduce.png b/1-js/05-data-types/05-array-methods/reduce.png
index 41476d2ae..7566c4d84 100644
Binary files a/1-js/05-data-types/05-array-methods/reduce.png and b/1-js/05-data-types/05-array-methods/reduce.png differ
diff --git a/1-js/05-data-types/05-array-methods/reduce@2x.png b/1-js/05-data-types/05-array-methods/reduce@2x.png
index f31647d17..7c9fd6692 100644
Binary files a/1-js/05-data-types/05-array-methods/reduce@2x.png and b/1-js/05-data-types/05-array-methods/reduce@2x.png differ
diff --git a/1-js/05-data-types/07-map-set-weakmap-weakset/02-filter-anagrams/solution.md b/1-js/05-data-types/07-map-set-weakmap-weakset/02-filter-anagrams/solution.md
index 0e841a9a2..236fa224c 100644
--- a/1-js/05-data-types/07-map-set-weakmap-weakset/02-filter-anagrams/solution.md
+++ b/1-js/05-data-types/07-map-set-weakmap-weakset/02-filter-anagrams/solution.md
@@ -59,7 +59,7 @@ Qui potremmo anche utilizzare un normale oggetto piuttosto di `Map`, poiché le
 
 Questo è un esempio di possibile soluzione:
 
-```js run
+```js run demo
 function aclean(arr) {
   let obj = {};
 
@@ -68,7 +68,7 @@ function aclean(arr) {
     obj[sorted] = arr[i];
   }
 
-  return Array.from(Object.values(obj));
+  return Object.values(obj);
 }
 
 let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
diff --git a/1-js/05-data-types/07-map-set-weakmap-weakset/03-iterable-keys/task.md b/1-js/05-data-types/07-map-set-weakmap-weakset/03-iterable-keys/task.md
index c4aec4624..6724d0f3a 100644
--- a/1-js/05-data-types/07-map-set-weakmap-weakset/03-iterable-keys/task.md
+++ b/1-js/05-data-types/07-map-set-weakmap-weakset/03-iterable-keys/task.md
@@ -16,7 +16,7 @@ map.set("name", "John");
 let keys = map.keys();
 
 *!*
-// Error: numbers.push is not a function
+// Error: keys.push is not a function
 keys.push("more");
 */!*
 ```
diff --git a/1-js/05-data-types/07-map-set-weakmap-weakset/article.md b/1-js/05-data-types/07-map-set-weakmap-weakset/article.md
index 17ea91368..fc039a140 100644
--- a/1-js/05-data-types/07-map-set-weakmap-weakset/article.md
+++ b/1-js/05-data-types/07-map-set-weakmap-weakset/article.md
@@ -159,6 +159,7 @@ L'iterazione segue lo stesso ordine in cui sono stati inseriti i valori. `Map` c
 Inoltre, `Map` possiede un metodo integrato `forEach`, simile agli `Array`:
 
 ```js
+// runs the function for each (key, value) pair 
 recipeMap.forEach( (value, key, map) => {
   alert(`${key}: ${value}`); // cucumber: 500 etc
 });
@@ -327,7 +328,7 @@ Fate il confronto con l'esempio di `Map` sopra. Ora se `john` esiste solo come c
 
 - `weakMap.get(key)`
 - `weakMap.set(key, value)`
-- `weakMap.delete(key, value)`
+- `weakMap.delete(key)`
 - `weakMap.has(key)`
 
 Perché questa limitazione? Per ragioni tecniche. Se un oggetto ha perso tutti i riferimenti (come `john` nel codice sopra), allora verrà automaticamente eliminato. Ma tecnicamente non è specificato esattamente quando *averrà la pulizia*.
diff --git a/1-js/05-data-types/08-keys-values-entries/01-sum-salaries/solution.md b/1-js/05-data-types/08-keys-values-entries/01-sum-salaries/solution.md
index e69de29bb..27a7b418a 100644
--- a/1-js/05-data-types/08-keys-values-entries/01-sum-salaries/solution.md
+++ b/1-js/05-data-types/08-keys-values-entries/01-sum-salaries/solution.md
@@ -0,0 +1,29 @@
+```js run demo
+function sumSalaries(salaries) {
+
+  let sum = 0;
+  for (let salary of Object.values(salaries)) {
+    sum += salary;
+  }
+
+  return sum; // 650
+}
+
+let salaries = {
+  "John": 100,
+  "Pete": 300,
+  "Mary": 250
+};
+
+alert( sumSalaries(salaries) ); // 650
+```
+Or, optionally, we could also get the sum using `Object.values` and `reduce`:
+
+```js
+// reduce loops over array of salaries,
+// adding them up
+// and returns the result
+function sumSalaries(salaries) {
+  return Object.values(salaries).reduce((a, b) => a + b, 0) // 650
+}
+```
diff --git a/1-js/05-data-types/08-keys-values-entries/article.md b/1-js/05-data-types/08-keys-values-entries/article.md
index 8a3865887..8ba096d3c 100644
--- a/1-js/05-data-types/08-keys-values-entries/article.md
+++ b/1-js/05-data-types/08-keys-values-entries/article.md
@@ -45,7 +45,7 @@ let user = {
 };
 ```
 
-- `Object.keys(user) = [name, age]`
+- `Object.keys(user) = ["name", "age"]`
 - `Object.values(user) = ["John", 30]`
 - `Object.entries(user) = [ ["name","John"], ["age",30] ]`
 
diff --git a/1-js/05-data-types/09-destructuring-assignment/6-max-salary/_js.view/solution.js b/1-js/05-data-types/09-destructuring-assignment/6-max-salary/_js.view/solution.js
index d95cf1b1e..f4bd5c761 100644
--- a/1-js/05-data-types/09-destructuring-assignment/6-max-salary/_js.view/solution.js
+++ b/1-js/05-data-types/09-destructuring-assignment/6-max-salary/_js.view/solution.js
@@ -3,7 +3,7 @@ function topSalary(salaries) {
   let max = 0;
   let maxName = null;
 
-  for(let [name, salary] of Object.entries(salaries)) {
+  for(const [name, salary] of Object.entries(salaries)) {
     if (max < salary) {
       max = salary;
       maxName = name;
diff --git a/1-js/05-data-types/09-destructuring-assignment/article.md b/1-js/05-data-types/09-destructuring-assignment/article.md
index 116f0dd15..d58a3a26d 100644
--- a/1-js/05-data-types/09-destructuring-assignment/article.md
+++ b/1-js/05-data-types/09-destructuring-assignment/article.md
@@ -43,19 +43,28 @@ let surname = arr[1];
 ```
 ````
 
+<<<<<<< HEAD
 ````smart header="Ignora i primi elementi"
 Possono essere ignorati degli elementi dell'array inserendo una virgola:
+=======
+````smart header="Ignore elements using commas"
+Unwanted elements of the array can also be thrown away via an extra comma:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 *!*
-// first and second elements are not needed
-let [, , title] = ["Julius", "Caesar", "Consul", "of the Roman Republic"];
+// second element is not needed
+let [firstName, , title] = ["Julius", "Caesar", "Consul", "of the Roman Republic"];
 */!*
 
 alert( title ); // Consul
 ```
 
+<<<<<<< HEAD
 Nel codice sopra, il primo e secondo elemento vengono saltati, il terzo viene assegnato a `title`, il resto dell'array viene ignorato.
+=======
+In the code above, the second element of the array is skipped, the third one is assigned to `title`, and the rest of the array is also skipped.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ````
 
 ````smart header="Funziona con qualsiasi itarabile"
@@ -129,6 +138,7 @@ alert(name1); // Julius
 alert(name2); // Caesar
 
 *!*
+// Note that type of `rest` is Array.
 alert(rest[0]); // Consul
 alert(rest[1]); // of the Roman Republic
 alert(rest.length); // 2
@@ -147,6 +157,7 @@ let [firstName, surname] = [];
 */!*
 
 alert(firstName); // undefined
+alert(surname); // undefined
 ```
 
 Se volessimo utilizzare un nostro valore di "default", potremmo fornirlo con la sintassi `=`:
@@ -336,7 +347,11 @@ Il problema è che JavaScript tratta `{...}` come un blocco di codice. Questo bl
 }
 ```
 
+<<<<<<< HEAD
 Per informare JavaScript che non ci troviamo in un blocco di codice, possiamo raggruppare l'intera assegnazione tra parentesi `(...)`:
+=======
+To show JavaScript that it's not a code block, we can wrap the whole assignment in parentheses `(...)`:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let title, width, height;
@@ -384,6 +399,8 @@ alert(item2);  // Donut
 
 L'intero oggetto `options` ad eccezione di `extra` il quale non viene menzionato, viene assegnato alle corrispondenti variabili.
 
+Note that `size` and `items` itself is not destructured.
+
 ![](destructuring-complex.png)
 
 Infine, abbiamo `width`, `height`, `item1`, `item2` e `title` che assumo il valore di default.
diff --git a/1-js/05-data-types/09-destructuring-assignment/destructuring-complex.png b/1-js/05-data-types/09-destructuring-assignment/destructuring-complex.png
index 50c4ffc93..c46bf6e45 100644
Binary files a/1-js/05-data-types/09-destructuring-assignment/destructuring-complex.png and b/1-js/05-data-types/09-destructuring-assignment/destructuring-complex.png differ
diff --git a/1-js/05-data-types/09-destructuring-assignment/destructuring-complex@2x.png b/1-js/05-data-types/09-destructuring-assignment/destructuring-complex@2x.png
index bb908281d..26032a3d6 100644
Binary files a/1-js/05-data-types/09-destructuring-assignment/destructuring-complex@2x.png and b/1-js/05-data-types/09-destructuring-assignment/destructuring-complex@2x.png differ
diff --git a/1-js/05-data-types/10-date/2-get-week-day/solution.md b/1-js/05-data-types/10-date/2-get-week-day/solution.md
index 479951fd6..306c58935 100644
--- a/1-js/05-data-types/10-date/2-get-week-day/solution.md
+++ b/1-js/05-data-types/10-date/2-get-week-day/solution.md
@@ -2,7 +2,7 @@ Il metodo `date.getDay()` ritorna il numero del giorno della settimana, comincia
 
 Creiamo quindi un array di giorni della settimana, che utilizzeremo per assegnare il numero della settimana al giorno corretto:
 
-```js run
+```js run demo
 function getWeekDay(date) {
   let days = ['DOM', 'LUN', 'MAR', 'MER', 'GIO', 'VEN', 'SAB'];
 
diff --git a/1-js/05-data-types/10-date/3-weekday/solution.md b/1-js/05-data-types/10-date/3-weekday/solution.md
index bfe3f4cac..e69de29bb 100644
--- a/1-js/05-data-types/10-date/3-weekday/solution.md
+++ b/1-js/05-data-types/10-date/3-weekday/solution.md
@@ -1,14 +0,0 @@
-```js run
-function getLocalDay(date) {
-
-  let day = date.getDay();
-
-  if (day == 0) { // 0 becomes 7
-    day = 7;
-  }
-
-  return day;
-}
-
-alert( getLocalDay(new Date(2012, 0, 3)) ); // 2
-```
diff --git a/1-js/05-data-types/10-date/4-get-date-ago/solution.md b/1-js/05-data-types/10-date/4-get-date-ago/solution.md
index e177c14ad..e174330e7 100644
--- a/1-js/05-data-types/10-date/4-get-date-ago/solution.md
+++ b/1-js/05-data-types/10-date/4-get-date-ago/solution.md
@@ -11,7 +11,7 @@ function getDateAgo(date, days) {
 
 Per implementarlo correttamente dovremmo clonare l'oggetto, come nel codice seguente:
 
-```js run
+```js run demo
 function getDateAgo(date, days) {
   let dateCopy = new Date(date);
 
diff --git a/1-js/05-data-types/10-date/5-last-day-of-month/solution.md b/1-js/05-data-types/10-date/5-last-day-of-month/solution.md
index 6287abbd3..1c01d1cbd 100644
--- a/1-js/05-data-types/10-date/5-last-day-of-month/solution.md
+++ b/1-js/05-data-types/10-date/5-last-day-of-month/solution.md
@@ -1,5 +1,10 @@
+<<<<<<< HEAD
 Creiamo un oggetto `date` con il mese successivo, e come giorno passiamo zero:
 ```js run
+=======
+Let's create a date using the next month, but pass zero as the day:
+```js run demo
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 function getLastDayOfMonth(year, month) {
   let date = new Date(year, month + 1, 0);
   return date.getDate();
diff --git a/1-js/05-data-types/10-date/6-get-seconds-today/solution.md b/1-js/05-data-types/10-date/6-get-seconds-today/solution.md
index 74423510c..25a229a7b 100644
--- a/1-js/05-data-types/10-date/6-get-seconds-today/solution.md
+++ b/1-js/05-data-types/10-date/6-get-seconds-today/solution.md
@@ -22,5 +22,5 @@ Una soluzione alternativa potrebbe essere quella di ottenere ore/minuti/secondi
 function getSecondsToday() {
   let d = new Date();
   return d.getHours() * 3600 + d.getMinutes() * 60 + d.getSeconds();
-};
+}
 ```
diff --git a/1-js/05-data-types/10-date/8-format-date-relative/solution.md b/1-js/05-data-types/10-date/8-format-date-relative/solution.md
index a569e354f..8ba39e8f0 100644
--- a/1-js/05-data-types/10-date/8-format-date-relative/solution.md
+++ b/1-js/05-data-types/10-date/8-format-date-relative/solution.md
@@ -1,6 +1,6 @@
 Per ottenere il tempo passato da `date` fino ad ora -- sottraiamo le date.
 
-```js run
+```js run demo
 function formatDate(date) {
   let diff = new Date() - date; // the difference in milliseconds
 
@@ -57,12 +57,12 @@ function formatDate(date) {
   let diffSec = Math.round(diffMs / 1000);
   let diffMin = diffSec / 60;
   let diffHour = diffMin / 60;
-      
+
   // formatting
   year = year.toString().slice(-2);
   month = month < 10 ? '0' + month : month;
   dayOfMonth = dayOfMonth < 10 ? '0' + dayOfMonth : dayOfMonth;
-      
+
   if (diffSec < 1) {
     return 'right now';  
   } else if (diffMin < 1) {
diff --git a/1-js/05-data-types/10-date/article.md b/1-js/05-data-types/10-date/article.md
index efa021ae4..1dd3eab0c 100644
--- a/1-js/05-data-types/10-date/article.md
+++ b/1-js/05-data-types/10-date/article.md
@@ -2,7 +2,11 @@
 
 Ora analizziamo un nuovo oggetto integrato: [Date](mdn:js/Date). Che memorizza la data, l'ora e fornisce dei metodi utili per il trattamento della data/ora.
 
+<<<<<<< HEAD
 Ad esempio, possiamo utilizzarlo per memorizzare modifiche su orari, o per misurare il tempo, o solamente per ottenere l'informazione della data corrente.
+=======
+For instance, we can use it to store creation/modification times, to measure time, or just to print out the current date.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## Creazione
 
@@ -39,7 +43,13 @@ Per creare un nuovo oggetto `Date`, chiamiamo `new Date()` con uno dei seguenti
 
     ```js run
     let date = new Date("2017-01-26");
-    alert(date); // Thu Jan 26 2017 ...
+    alert(date);
+    // The time portion of the date is assumed to be midnight GMT and 
+    // is adjusted according to the timezone the code is run in
+    // So the result could be
+    // Thu Jan 26 2017 11:00:00 GMT+1100 (Australian Eastern Daylight Time)
+    // or
+    // Wed Jan 25 2017 16:00:00 GMT-0800 (Pacific Standard Time)
     ```
 
 `new Date(year, month, date, hours, minutes, seconds, ms)`
@@ -108,8 +118,12 @@ alert( date.getHours() );
 alert( date.getUTCHours() );
 ```
 
+<<<<<<< HEAD
 
 Oltre ai metodi forniti, ce ne sono altri due di speciali, che non possiedono la variante UTC:
+=======
+Besides the given methods, there are two special ones that do not have a UTC-variant:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 [getTime()](mdn:js/Date/getTime)
 : Ritorna il timestamp della data -- il numero di millisecondi trascorsi dal 1 Gennaio 1970 in UTC+0.
@@ -420,4 +434,8 @@ alert(`Loading started ${performance.now()}ms ago`);
 // more than 3 digits after the decimal point are precision errors, but only the first 3 are correct
 ```
 
+<<<<<<< HEAD
 Node.JS possiede un modulo `microtime` e altri metodi. Tecnicamente, la maggior parte degli ambienti forniscono un modo per gestire precisioni più elevate, questo non è pero previsto dall'oggetto `Date`.
+=======
+Node.js has `microtime` module and other ways. Technically, any device and environment allows to get more precision, it's just not in `Date`.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/05-data-types/11-json/article.md b/1-js/05-data-types/11-json/article.md
index 07c4bc49d..d6ec47a28 100644
--- a/1-js/05-data-types/11-json/article.md
+++ b/1-js/05-data-types/11-json/article.md
@@ -359,7 +359,11 @@ alert( JSON.stringify(meetup) );
 
 Qui possiamo vedere che `date` `(1)` diventa una stringa. Questo accade perché tutti gi oggetti di tipo `Date` possiedono un metodo `toJSON`.
 
+<<<<<<< HEAD
 Ora proviamo ad aggiungere un metodo `toJSON` personalizzato per il nostro oggetto `room`:
+=======
+Now let's add a custom `toJSON` for our object `room` `(2)`:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 let room = {
diff --git a/1-js/05-data-types/11-json/json-meetup.png b/1-js/05-data-types/11-json/json-meetup.png
index 0a26e0a67..268666424 100644
Binary files a/1-js/05-data-types/11-json/json-meetup.png and b/1-js/05-data-types/11-json/json-meetup.png differ
diff --git a/1-js/05-data-types/11-json/json-meetup@2x.png b/1-js/05-data-types/11-json/json-meetup@2x.png
index b5f6a4012..a8f2cd609 100644
Binary files a/1-js/05-data-types/11-json/json-meetup@2x.png and b/1-js/05-data-types/11-json/json-meetup@2x.png differ
diff --git a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/fibonacci-recursion-tree.png b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/fibonacci-recursion-tree.png
index c45418ff4..d0d37e35e 100644
Binary files a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/fibonacci-recursion-tree.png and b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/fibonacci-recursion-tree.png differ
diff --git a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/fibonacci-recursion-tree@2x.png b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/fibonacci-recursion-tree@2x.png
index 6fc39ae13..3a937c64c 100644
Binary files a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/fibonacci-recursion-tree@2x.png and b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/fibonacci-recursion-tree@2x.png differ
diff --git a/1-js/06-advanced-functions/01-recursion/linked-list-0.png b/1-js/06-advanced-functions/01-recursion/linked-list-0.png
index 000a80da8..c694e7021 100644
Binary files a/1-js/06-advanced-functions/01-recursion/linked-list-0.png and b/1-js/06-advanced-functions/01-recursion/linked-list-0.png differ
diff --git a/1-js/06-advanced-functions/01-recursion/linked-list-0@2x.png b/1-js/06-advanced-functions/01-recursion/linked-list-0@2x.png
index 5a2368694..1fe50ace4 100644
Binary files a/1-js/06-advanced-functions/01-recursion/linked-list-0@2x.png and b/1-js/06-advanced-functions/01-recursion/linked-list-0@2x.png differ
diff --git a/1-js/06-advanced-functions/01-recursion/linked-list-remove-1.png b/1-js/06-advanced-functions/01-recursion/linked-list-remove-1.png
index 477989ad8..b4c89ecdf 100644
Binary files a/1-js/06-advanced-functions/01-recursion/linked-list-remove-1.png and b/1-js/06-advanced-functions/01-recursion/linked-list-remove-1.png differ
diff --git a/1-js/06-advanced-functions/01-recursion/linked-list-remove-1@2x.png b/1-js/06-advanced-functions/01-recursion/linked-list-remove-1@2x.png
index 41de7661c..6b5b95a0f 100644
Binary files a/1-js/06-advanced-functions/01-recursion/linked-list-remove-1@2x.png and b/1-js/06-advanced-functions/01-recursion/linked-list-remove-1@2x.png differ
diff --git a/1-js/06-advanced-functions/01-recursion/linked-list-split.png b/1-js/06-advanced-functions/01-recursion/linked-list-split.png
index ac2203490..310a36066 100644
Binary files a/1-js/06-advanced-functions/01-recursion/linked-list-split.png and b/1-js/06-advanced-functions/01-recursion/linked-list-split.png differ
diff --git a/1-js/06-advanced-functions/01-recursion/linked-list-split@2x.png b/1-js/06-advanced-functions/01-recursion/linked-list-split@2x.png
index 201c66f15..2de39ca4f 100644
Binary files a/1-js/06-advanced-functions/01-recursion/linked-list-split@2x.png and b/1-js/06-advanced-functions/01-recursion/linked-list-split@2x.png differ
diff --git a/1-js/06-advanced-functions/01-recursion/linked-list.png b/1-js/06-advanced-functions/01-recursion/linked-list.png
index 64b6fb2b7..80fabffc6 100644
Binary files a/1-js/06-advanced-functions/01-recursion/linked-list.png and b/1-js/06-advanced-functions/01-recursion/linked-list.png differ
diff --git a/1-js/06-advanced-functions/01-recursion/linked-list@2x.png b/1-js/06-advanced-functions/01-recursion/linked-list@2x.png
index c28fa8259..1e6dc1483 100644
Binary files a/1-js/06-advanced-functions/01-recursion/linked-list@2x.png and b/1-js/06-advanced-functions/01-recursion/linked-list@2x.png differ
diff --git a/1-js/06-advanced-functions/01-recursion/recursion-pow.png b/1-js/06-advanced-functions/01-recursion/recursion-pow.png
index 30577f89c..354f01271 100644
Binary files a/1-js/06-advanced-functions/01-recursion/recursion-pow.png and b/1-js/06-advanced-functions/01-recursion/recursion-pow.png differ
diff --git a/1-js/06-advanced-functions/01-recursion/recursion-pow@2x.png b/1-js/06-advanced-functions/01-recursion/recursion-pow@2x.png
index c19973420..22ae94410 100644
Binary files a/1-js/06-advanced-functions/01-recursion/recursion-pow@2x.png and b/1-js/06-advanced-functions/01-recursion/recursion-pow@2x.png differ
diff --git a/1-js/06-advanced-functions/01-recursion/recursive-salaries.png b/1-js/06-advanced-functions/01-recursion/recursive-salaries.png
index 2b9015409..b40783a9b 100644
Binary files a/1-js/06-advanced-functions/01-recursion/recursive-salaries.png and b/1-js/06-advanced-functions/01-recursion/recursive-salaries.png differ
diff --git a/1-js/06-advanced-functions/01-recursion/recursive-salaries@2x.png b/1-js/06-advanced-functions/01-recursion/recursive-salaries@2x.png
index 261ab144e..e37597128 100644
Binary files a/1-js/06-advanced-functions/01-recursion/recursive-salaries@2x.png and b/1-js/06-advanced-functions/01-recursion/recursive-salaries@2x.png differ
diff --git a/1-js/06-advanced-functions/02-rest-parameters-spread-operator/article.md b/1-js/06-advanced-functions/02-rest-parameters-spread-operator/article.md
index 0374c6b87..878dfd8d9 100644
--- a/1-js/06-advanced-functions/02-rest-parameters-spread-operator/article.md
+++ b/1-js/06-advanced-functions/02-rest-parameters-spread-operator/article.md
@@ -61,8 +61,13 @@ function showName(firstName, lastName, ...titles) {
 showName("Julius", "Caesar", "Consul", "Imperator");
 ```
 
+<<<<<<< HEAD
 ````warn header="I parametri resto devono apparire alla fine"
 I parametri resto raccolgono tutti gli argomenti che avanzano, quindi non avrebbe senso fare:
+=======
+````warn header="The rest parameters must be at the end"
+The rest parameters gather all remaining arguments, so the following does not make sense and causes an error:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js
 function f(arg1, ...rest, arg2) { // arg2 after ...rest ?!
diff --git a/1-js/06-advanced-functions/03-closure/4-closure-sum/solution.md b/1-js/06-advanced-functions/03-closure/4-closure-sum/solution.md
index 28e3614a0..a741b8945 100644
--- a/1-js/06-advanced-functions/03-closure/4-closure-sum/solution.md
+++ b/1-js/06-advanced-functions/03-closure/4-closure-sum/solution.md
@@ -1,4 +1,8 @@
+<<<<<<< HEAD
 Perchè la seconda parentesi funzioni, la prima deve ritornare una funzione.
+=======
+For the second parentheses to work, the first ones must return a function.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Come in questo esempio:
 
diff --git a/1-js/06-advanced-functions/03-closure/4-closure-sum/task.md b/1-js/06-advanced-functions/03-closure/4-closure-sum/task.md
index a95063e8e..f21a22ad3 100644
--- a/1-js/06-advanced-functions/03-closure/4-closure-sum/task.md
+++ b/1-js/06-advanced-functions/03-closure/4-closure-sum/task.md
@@ -6,7 +6,11 @@ importance: 4
 
 Scrivete la funzione `sum` che funziona in questo modo: `sum(a)(b) = a+b`.
 
+<<<<<<< HEAD
 Esattamente, due parentesi tonde (non è un errore).
+=======
+Yes, exactly this way, using double parentheses (not a mistype).
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio:
 
diff --git a/1-js/06-advanced-functions/03-closure/6-filter-through-function/solution.md b/1-js/06-advanced-functions/03-closure/6-filter-through-function/solution.md
index 5bbc33b02..46c5514a8 100644
--- a/1-js/06-advanced-functions/03-closure/6-filter-through-function/solution.md
+++ b/1-js/06-advanced-functions/03-closure/6-filter-through-function/solution.md
@@ -14,7 +14,7 @@ alert( arr.filter(inBetween(3, 6)) ); // 3,4,5,6
 
 # Filter inArray
 
-```js run
+```js run demo
 function inArray(arr) {
   return function(x) {
     return arr.includes(x);
diff --git a/1-js/06-advanced-functions/03-closure/8-make-army/lexenv-makearmy.png b/1-js/06-advanced-functions/03-closure/8-make-army/lexenv-makearmy.png
index d51e8167f..8e39564ff 100644
Binary files a/1-js/06-advanced-functions/03-closure/8-make-army/lexenv-makearmy.png and b/1-js/06-advanced-functions/03-closure/8-make-army/lexenv-makearmy.png differ
diff --git a/1-js/06-advanced-functions/03-closure/8-make-army/lexenv-makearmy@2x.png b/1-js/06-advanced-functions/03-closure/8-make-army/lexenv-makearmy@2x.png
index e70edbd6d..39cc13a42 100644
Binary files a/1-js/06-advanced-functions/03-closure/8-make-army/lexenv-makearmy@2x.png and b/1-js/06-advanced-functions/03-closure/8-make-army/lexenv-makearmy@2x.png differ
diff --git a/1-js/06-advanced-functions/03-closure/8-make-army/solution.md b/1-js/06-advanced-functions/03-closure/8-make-army/solution.md
index fb6b4c8c7..a00f3132c 100644
--- a/1-js/06-advanced-functions/03-closure/8-make-army/solution.md
+++ b/1-js/06-advanced-functions/03-closure/8-make-army/solution.md
@@ -55,9 +55,13 @@ function makeArmy() {
 
 Il risultato è che tutte le funzioni `shooter` la prendono dallo stesso lexical envrironment esterno, in cui l'ultimo valore è `i=10`.
 
+<<<<<<< HEAD
 Questo può essere sistemato molto facilmente:
+=======
+We can fix it by moving the variable definition into the loop:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
-```js run
+```js run demo
 function makeArmy() {
 
   let shooters = [];
@@ -81,7 +85,13 @@ army[5](); // 5
 ```
 Ora funziona correttamente, perché ogni volta che viene eseguito il blocco di codice `for (..) {...}`, viene creato un nuovo Lexical Environment, con il corrispondente valore `i`.
 
+<<<<<<< HEAD
 Quindi, il valore di `i` ora si trova più "vicino". Non più nel lexical environment di `makeArmy()`, ma in quello del corrispondente ciclo. Uno `shooter` preleva il valore esattamente da dove è stato creato.
+=======
+Now it works correctly, because every time the code block in `for (let i=0...) {...}` is executed, a new Lexical Environment is created for it, with the corresponding variable `i`.
+
+So, the value of `i` now lives a little bit closer. Not in `makeArmy()` Lexical Environment, but in the Lexical Environment that corresponds the current loop iteration. That's why now it works.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ![](lexenv-makearmy.png)
 
@@ -89,7 +99,6 @@ Qui abbiamo riscritto `while` in `for`.
 
 Eì possibile farlo in un altro modo, vediamolo per capirlo meglio:
 
-
 ```js run
 function makeArmy() {
   let shooters = [];
diff --git a/1-js/06-advanced-functions/03-closure/article.md b/1-js/06-advanced-functions/03-closure/article.md
index 4d57c0083..ae7613a42 100644
--- a/1-js/06-advanced-functions/03-closure/article.md
+++ b/1-js/06-advanced-functions/03-closure/article.md
@@ -70,7 +70,11 @@ L'oggetto Lexical Environment consiste di due parti:
 1. *Environment Record* -- un oggetto che contiene tutte le variabili locali e le relative proprietà (e alcune altre informazioni come il valore di  `this`).
 2. Un riferimento al *outer lexical environment* (lexical environment esterno).
 
+<<<<<<< HEAD
 Quindi, una "variabile" è solamente una proprietà di questo speciale oggetto, l'Environment Record. "Per ottenere o modificare una variabile" si traduce in "per ottenere o modificare una variabile del Lexical Environment".
+=======
+**So, a "variable" is just a property of the special internal object, Environment Record. "To get or change a variable" means "to get or change a property of that object".**
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio, in questo semplice codice, esiste un solo Lexical Environment:
 
@@ -100,7 +104,15 @@ Per ricapitolare:
 
 ### Dichiarazione di funzione
 
+<<<<<<< HEAD
 Le dichiarazioni di funzione sono speciali. A differenza di `let` per le variabili, vengono processate non quando il flusso d'esecuzione le incontra, ma quando il Lexical Environment viene creato. Nel caso del global Lexical Environment, significa all'inizio dello script.
+=======
+Till now, we only observed variables. Now enter Function Declarations.
+
+**Unlike `let` variables, they are fully initialized not when the execution reaches them, but earlier, when a Lexical Environment is created.**
+
+For top-level functions, it means the moment when the script is started.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Questo è il motivo per cui possiamo chiamare una funzione prima della sua definizione.
 
@@ -111,10 +123,18 @@ Il codice sotto dimostra che il Lexical Environment inizialmente non è vuoto. C
 
 ### Lexical Environment interno ed esterno
 
+<<<<<<< HEAD
 Durante la sua esecuzione, `say()` utilizza una variabile esterna, quindi proviamo ad analizzare più in dettaglio cosa sta succedendo.
+=======
+Now let's go on and explore what happens when a function accesses an outer variable.
+
+During the call, `say()` uses the outer variable `phrase`, let's look at the details of what's going on.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Inizialmente, quando una funzione viene eseguita, viene creato un nuovo Lexical Environment per la funzione. Questa è una regola generale valida per tutte le funzioni. Questo Lexical Environment viene utilizzato per memorizzare le variabili locali e i parametri.
 
+For instance, for `say("John")`, it looks like this (the execution is at the line, labelled with an arrow):
+
 <!--
     ```js
     let phrase = "Hello";
@@ -126,12 +146,16 @@ Inizialmente, quando una funzione viene eseguita, viene creato un nuovo Lexical
     say("John"); // Hello, John
     ```-->
 
+<<<<<<< HEAD
 In questa figura vediamo il contenuto del Lexical Environments quando il flusso d'esecuzione si trova all0interno di `say("John")`, nella riga etichettata con la freccia:
 
+=======
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 ![lexical environment](lexical-environment-simple.png)
  
 Durante la chiamata di funzione abbiamo due Lexical Environments: quello interno (relativo alla funzione) e quello esterno (globale):
 
+<<<<<<< HEAD
 - Il Lexical Environment interno che corrisponde all'esecuzione di `say`. Che possiede una sola variabile: `name`, che è l'unico argomento della funzione. Abbiamo invocato `say("John")`, quindi il valore di name `name` è `"John"`.
 - Il Lexical Environment esterno è quello globale.
 
@@ -140,11 +164,32 @@ Il Lexical Environment interno ha un riferimento a quello esterno, memorizzato s
 **Quando il codice vuole accedere ad una variabile -- come prima cosa la si cerca nel Lexical Environment interno, successivamente in quello esterno, poi in quello ancora più esterno e cosi via fino a quello più esterno.**
 
  Se una variabile non viene trovata, si ha un errore in strict mode. Senza `use strict`, viene creata una variabile globale, per consentire la retro-compatibilità.
+=======
+So, during the function call we have two Lexical Environments: the inner one (for the function call) and the outer one (global):
+
+- The inner Lexical Environment corresponds to the current execution of `say`.
+
+    It has a single variable: `name`, the function argument. We called `say("John")`, so the value of `name` is `"John"`.
+- The outer Lexical Environment is the global Lexical Environment.
+
+    It has `phrase` and the function itself.
+
+The inner Lexical Environment has a reference to the outer one.
+
+**When the code wants to access a variable -- the inner Lexical Environment is searched first, then the outer one, then the more outer one and so on until the end of the chain.**
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Vediamo come procede la ricerca nel nostro esempio:
 
+<<<<<<< HEAD
 - Quando `alert` all'interno di `say` vuole accedere a `name`, trova la variabile immediatamente nel Lexical Environment della funzione.
 - Quando vuole accedere a `phrase`, non trova nessun `phrase` localmente, quindi segue il riferimento `outer` e la trova nel Lexical Environment esterno.
+=======
+Let's see how the search proceeds in our example:
+
+- When the `alert` inside `say` wants to access `name`, it finds it immediately in the function Lexical Environment.
+- When it wants to access `phrase`, then there is no `phrase` locally, so it follows the reference to the enclosing Lexical Environment and finds it there.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ![lexical environment lookup](lexical-environment-simple-lookup.png)
 
@@ -211,11 +256,19 @@ function sayHiBye(firstName, lastName) {
 }
 ```
 
+<<<<<<< HEAD
 Qui la funzione *annidata*  `getFullName()` è stata creata per comodità. Può accedere alle variabili esterne quindi può ritornarne il nome completo.
 
 Un'altra cosa interessante, una funzione annidata può essere ritornata: sia come proprietà di un nuovo oggetto(se la funzione esterna crea un oggetto con dei metodi) o come risultato stesso. Può essere salvata e utilizzata da qualsiasi altra parte. Non ha importanza dove, avrà comunque accesso alle stesse variabili esterne.
 
 Un esempio con il costruttore (vedere il capitolo <info:constructor-new>):
+=======
+Here the *nested* function `getFullName()` is made for convenience. It can access the outer variables and so can return the full name. Nested functions are quite common in JavaScript.
+
+What's much more interesting, a nested function can be returned: either as a property of a new object (if the outer function creates an object with methods) or as a result by itself. It can then be used somewhere else. No matter where, it still has access to the same outer variables.
+
+For instance, here the nested function is assigned to the new object by the [constructor function](info:constructor-new):
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 // constructor function returns a new object
@@ -228,10 +281,14 @@ function User(name) {
 }
 
 let user = new User("John");
-user.sayHi(); // the method code has access to the outer "name"
+user.sayHi(); // the method "sayHi" code has access to the outer "name"
 ```
 
+<<<<<<< HEAD
 Un esempio con ritorno di funzione:
+=======
+And here we just create and return a "counting" function:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 function makeCounter() {
@@ -249,7 +306,11 @@ alert( counter() ); // 1
 alert( counter() ); // 2
 ```
 
+<<<<<<< HEAD
 Proseguiamo con l'esempio `makeCounter`. Crea una funzione "contatore" che ritorna il numero successivo ad ogni invocazione. Nonostante sia semplice, delle varianti modificate di questo codice hanno usi pratici, ad esempio, come [generatore di numeri pseudocasuali](https://en.wikipedia.org/wiki/Pseudorandom_number_generator), e molto altro. Quindi l'esempio non è cosi artificiale.
+=======
+Let's go on with the `makeCounter` example. It creates the "counter" function that returns the next number on each invocation. Despite being simple, slightly modified variants of that code have practical uses, for instance, as a [pseudorandom number generator](https://en.wikipedia.org/wiki/Pseudorandom_number_generator), and more.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Come funziona il counter internamente?
 
@@ -265,8 +326,13 @@ In questo esempio `count` viene trovata nel caso `2`. Quando una variabile ester
 
 Ci sono due considerazioni da fare:
 
+<<<<<<< HEAD
 1. Possiamo in qualche modo resettare la variabile `counter` da una parte di codice che non appartiene a `makeCounter`? Ad esempio dopo la chiamata ad `alert`.
 2. Se chiamiamo `makeCounter()` più volte -- ritorna più funzioni `counter`. Sono indipendenti tra loro oppure condividono il valore `count`?
+=======
+1. Can we somehow reset the counter `count` from the code that doesn't belong to `makeCounter`? E.g. after `alert` calls in the example above.
+2. If we call `makeCounter()` multiple times -- it returns many `counter` functions. Are they independent or do they share the same `count`?
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Prima di continuare provate a rispondere.
 
@@ -276,8 +342,13 @@ Fatto?
 
 Okay, allora vediamo le risposte.
 
+<<<<<<< HEAD
 1. No non c'è alcun modo di farlo. La variabile `counter` è locale alla funzione, non possiamo accedervi dall'esterno.
 2. Per ogni chiamata a `makeCounter()` viene creato un nuovo Lexical Environment, con i suoi `counter`. Quindi le funzioni `counter` sono indipendenti.
+=======
+1. There is no way: `count` is a local function variable, we can't access it from the outside.
+2. For every call to `makeCounter()` a new function Lexical Environment is created, with its own `count`. So the resulting `counter` functions are independent.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Vediamo un esempio di quanto detto:
 
@@ -303,9 +374,17 @@ Dovrebbe esservi abbastanza chiara la situazione delle variabili esterne. In alc
 
 ## Environment nel dettaglio
 
+<<<<<<< HEAD
 Ora che avete una maggiore conoscenza delle closure, possiamo scendere più in profondità.
 
 Qui analizziamo cosa succede nell'esempio `makeCounter` passo per passo, seguitelo attentamente per essere certi di comprenderne il funzionamento. Da notare un ulteriore proprietà `[[Environment]]` di cui non abbiamo ancora parlato.
+=======
+Now that you understand how closures work generally, that's already very good.
+
+Here's what's going on in the `makeCounter` example step-by-step, follow it to make sure that you know things in the very detail.
+
+Please note the additional `[[Environment]]` property is covered here. We didn't mention it before for simplicity.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 1. Quando lo script inizia, si ha solamente il Lexical Environment globale:
 
@@ -313,7 +392,11 @@ Qui analizziamo cosa succede nell'esempio `makeCounter` passo per passo, seguite
 
     Inizialmente si ha solamente la funzione `makeCounter`, perché è una dichiarazione di funzione. Non ha ancora eseguito.
 
+<<<<<<< HEAD
     Tutte le funzioni "alla nascita" ricevono una proprietà nascosta `[[Environment]]` con un riferimento al Lexical Environment corrispondente. Non lo avevamo spiegato finora, ma questo è il meccanismo con cui viene collegata la funzione al rispettivo Lexical Environment.
+=======
+    **All functions "on birth" receive a hidden property `[[Environment]]` with a reference to the Lexical Environment of their creation.** We didn't talk about it yet, but that's how the function knows where it was made.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
     Qui, `makeCounter` viene creata nel Lexical Environment globale, quindi `[[Environment]]` contiene un riferimento a questo.
 
@@ -389,13 +472,23 @@ Durante un'intervista ad un frontend developer, si potrebbe porre la domanda: "c
 
 ## Blocchi di codice e cicli, IIFE
 
+<<<<<<< HEAD
 Gli esempi sopra si sono concentrati sulle funzioni. Ma i Lexical Environment esistono anche per i blocchi di codice `{...}`.
 
 Vengono creati quando un blocco di codice viene eseguito e contiene le variabili locali. Vediamo un paio di esempi.
+=======
+The examples above concentrated on functions. But a Lexical Environment exists for any code block `{...}`.
+
+A Lexical Environment is created when a code block runs and contains block-local variables. Here are a couple of examples.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
-## If
+### If
 
+<<<<<<< HEAD
 In questo esempio, quando l'esecuzione arriva dentro il blocco `if`, viene creato un Lexical Environment relativo a "if":
+=======
+In the example below, the `user` variable exists only in the `if` block:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 <!--
     ```js run
@@ -412,11 +505,17 @@ In questo esempio, quando l'esecuzione arriva dentro il blocco `if`, viene creat
 
 ![](lexenv-if.png)
 
+<<<<<<< HEAD
 Il nuovo Lexical Environment ottiene un riferimento a quello esterno, quindi `phrase` è accessibile. Invece tutte le variabili e funzioni create all'interno del blocco `if` appartengono al Lexical Environment interno e non sono quindi accessibili dall'esterno.
+=======
+When the execution gets into the `if` block, the new "if-only" Lexical Environment is created for it.
+
+It has the reference to the outer one, so `phrase` can be found. But all variables and Function Expressions, declared inside `if`, reside in that Lexical Environment and can't be seen from the outside.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Ad esempio, quando `if` termina, la chiamata `alert` sotto non potrebbe accedere a `user`.
 
-## For, while
+### For, while
 
 Per un ciclo, ogni iterazione possiede un Lexical Environment separato. Se una variabile viene dichiarata in un ciclo `for`, allora questa è locale solamente a quel Lexical Environment:
 
@@ -429,9 +528,15 @@ for (let i = 0; i < 10; i++) {
 alert(i); // Error, no such variable
 ```
 
+<<<<<<< HEAD
 In realtà c'è un eccezione, poichè `let i` è visibilmente all'esterno di `{...}`. In realtà ogni esecuzione del ciclo ha il suo Lexical Environment personale, in cui è contenuta anche la variabile `i`.
 
 Al termine del ciclo, `i` non sarà più visibile.
+=======
+Please note: `let i` is visually outside of `{...}`. The `for` construct is somewhat special here: each iteration of the loop has its own Lexical Environment with the current `i` in it.
+
+Again, similarly to `if`, after the loop `i` is not visible.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ### Blocchi di codice
 
@@ -459,9 +564,19 @@ Il codice esterno al blocco (o di un altro script) non può vedere le variabili
 
 ### IIFE
 
+<<<<<<< HEAD
 Nei vecchi script, si può trovare la cosi detta "immediately-invoked function expressions" (abbreviato come IIFE) utilizzato per questo scopo.
 
 Appare cosi:
+=======
+In the past, there were no block-level lexical environment in JavaScript.
+
+So programmers had to invent something. And what they did is called "immediately-invoked function expressions" (abbreviated as IIFE).
+
+That's not a thing we should use nowadays, but you can find them in old scripts, so it's better to understand them.
+
+IIFE looks like this:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 (function() {
@@ -475,11 +590,15 @@ Appare cosi:
 
 Qui un'espressione di funzione viene creata e immediatamente invocata. Cosi il codice esegue con le sue variabili.
 
+<<<<<<< HEAD
 L'espressione di funzione viene raccolta tra parentesi `(function {...})`, perché quando JavaScript incontra `"function"` nel flusso principale del codice, la interpreta come dichiarazione di funzione. Ma una dichiarazione di funzione deve avere un nome, quindi ci sarebbe un errore:
+=======
+The Function Expression is wrapped with parenthesis `(function {...})`, because when JavaScript meets `"function"` in the main code flow, it understands it as the start of a Function Declaration. But a Function Declaration must have a name, so this kind of code will give an error:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
-// Error: Unexpected token (
-function() { // <-- JavaScript cannot find function name, meets ( and gives error
+// Try to declare and immediately call a function
+function() { // <-- Error: Unexpected token (
 
   let message = "Hello";
 
@@ -488,28 +607,38 @@ function() { // <-- JavaScript cannot find function name, meets ( and gives erro
 }();
 ```
 
+<<<<<<< HEAD
 Potremmo dire "okay, rendiamola una dichiarazione di funzione, aggiungiamo un nome", ma non funzionerebbe. JavaScript non consente di invocare immediatamente una dichiarazione di funzione:
+=======
+Even if we say: "okay, let's add a name", that won't work, as JavaScript does not allow Function Declarations to be called immediately:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
-// syntax error because of brackets below
+// syntax error because of parentheses below
 function go() {
 
 }(); // <-- can't call Function Declaration immediately
 ```
 
+<<<<<<< HEAD
 Quindi, le parentesi tonde sono necessario per indicare a JavaScript che la funzione viene creata nel contesto di un'altra espressione, e quindi è un espressione di funzione. Non c'è quindi bisogno di darle un nome e può essere invocata immediatamente.
 
 Ci sono anche altri modi per far capire a JavaScript che intendiamo utilizzare un espressione di funzione:
+=======
+So, parentheses around the function is a trick to show JavaScript that the function is created in the context of another expression, and hence it's a Function Expression: it needs no name and can be called immediately.
+
+There exist other ways besides parentheses to tell JavaScript that we mean a Function Expression:
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ```js run
 // Ways to create IIFE
 
 (function() {
-  alert("Brackets around the function");
+  alert("Parentheses around the function");
 }*!*)*/!*();
 
 (function() {
-  alert("Brackets around the whole thing");
+  alert("Parentheses around the whole thing");
 }()*!*)*/!*;
 
 *!*!*/!*function() {
@@ -525,68 +654,88 @@ In tutti i casi sopra noi dichiariamo un espressione di funzione e la invochiamo
 
 ## Garbage collection
 
+<<<<<<< HEAD
 Gli oggetti Lexical Environment di cui abbiamo parlato fino ad ora sono soggetti alle stesse regole di gestione della memoria.
 
 - Solitamente, un Lexical Environment viene rimosso dalla memoria quando la funzione termina la sua esecuzione. Ad esempio:
+=======
+Usually, a Lexical Environment is cleaned up and deleted after the function run. For instance:
 
-    ```js
-    function f() {
-      let value1 = 123;
-      let value2 = 456;
-    }
+```js
+function f() {
+  let value1 = 123;
+  let value2 = 456;
+}
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
-    f();
-    ```
+f();
+```
+
+Here two values are technically the properties of the Lexical Environment. But after `f()` finishes that Lexical Environment becomes unreachable, so it's deleted from the memory.
 
+<<<<<<< HEAD
     Qui i due valori sono tecnicamente le proprietà dell'oggetto Lexical Environment. Al termine di `f()` il Lexical Environment diventa irraggiungibile, quindi viene rimosso dalla memoria.
 
 - ...Ma se contiene una funzione annidata che risulta essere ancora raggiungibile al termine di `f`, allora il riferimento `[[Environment]]` mantiene il Lexical Environment esterno ancora in memoria:
+=======
+...But if there's a nested function that is still reachable after the end of `f`, then its `[[Environment]]` reference keeps the outer lexical environment alive as well:
 
-    ```js
-    function f() {
-      let value = 123;
+```js
+function f() {
+  let value = 123;
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
-      function g() { alert(value); }
+  function g() { alert(value); }
 
-    *!*
-      return g;
-    */!*
-    }
+*!*
+  return g;
+*/!*
+}
 
-    let g = f(); // g is reachable, and keeps the outer lexical environment in memory
-    ```
+let g = f(); // g is reachable, and keeps the outer lexical environment in memory
+```
 
+Please note that if `f()` is called many times, and resulting functions are saved, then the corresponding Lexical Environment objects will also be retained in memory. All 3 of them in the code below:
+
+<<<<<<< HEAD
 - Da notare che se `f()` viene invocata più volte, e vengono memorizzate delle funzioni, allora anche i corrispondenti Lexical Environment vengono mantenuti in memoria. E' il caso dell'esempio qui sotto:
+=======
+```js
+function f() {
+  let value = Math.random();
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
-    ```js
-    function f() {
-      let value = Math.random();
+  return function() { alert(value); };
+}
 
-      return function() { alert(value); };
-    }
+// 3 functions in array, every one of them links to Lexical Environment
+// from the corresponding f() run
+//         LE   LE   LE
+let arr = [f(), f(), f()];
+```
 
-    // 3 functions in array, every one of them links to Lexical Environment
-    // from the corresponding f() run
-    //         LE   LE   LE
-    let arr = [f(), f(), f()];
-    ```
+A Lexical Environment object dies when it becomes unreachable (just like any other object). In other words, it exists only while there's at least one nested function referencing it.
 
+<<<<<<< HEAD
 - Un oggetto Lexical Environment muore quando diventa irraggiungibile: quando nessuna funzione annidata ne mantiene un riferimento. Nel codice sotto, dopo che `g` diventa irraggiungibile, anche `value` viene rimosso dalla memoria:
+=======
+In the code below, after `g` becomes unreachable, enclosing Lexical Environment (and hence the `value`) is  cleaned from memory;
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
-    ```js
-    function f() {
-      let value = 123;
+```js
+function f() {
+  let value = 123;
 
-      function g() { alert(value); }
+  function g() { alert(value); }
 
-      return g;
-    }
+  return g;
+}
 
-    let g = f(); // while g is alive
-    // there corresponding Lexical Environment lives
+let g = f(); // while g is alive
+// there corresponding Lexical Environment lives
 
-    g = null; // ...and now the memory is cleaned up
-    ```
+g = null; // ...and now the memory is cleaned up
+```
 
 ### Ottimizzazioni nel mondo reale
 
diff --git a/1-js/06-advanced-functions/03-closure/lexenv-if.png b/1-js/06-advanced-functions/03-closure/lexenv-if.png
index a27fb309e..5a11b65de 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexenv-if.png and b/1-js/06-advanced-functions/03-closure/lexenv-if.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexenv-if@2x.png b/1-js/06-advanced-functions/03-closure/lexenv-if@2x.png
index 6da6f5b99..794676cda 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexenv-if@2x.png and b/1-js/06-advanced-functions/03-closure/lexenv-if@2x.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-1.png b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-1.png
index b3f9e8f04..c6083a452 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-1.png and b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-1.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-1@2x.png b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-1@2x.png
index 55a705d64..af57c51cd 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-1@2x.png and b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-1@2x.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-2.png b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-2.png
index 046d3ed47..dce67876f 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-2.png and b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-2.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-2@2x.png b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-2@2x.png
index ae4d40873..9bba88bc5 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-2@2x.png and b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-2@2x.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-3.png b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-3.png
index 9a28a8e95..4d5a787c2 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-3.png and b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-3.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-3@2x.png b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-3@2x.png
index 8a678bfb8..c7575f4d5 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-3@2x.png and b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-3@2x.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-4.png b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-4.png
index d3cee3f37..70b4a09bf 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-4.png and b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-4.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-4@2x.png b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-4@2x.png
index 7d1732baf..4cc762c10 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-4@2x.png and b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-4@2x.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-5.png b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-5.png
index dba908bdf..7410dddc8 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-5.png and b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-5.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-5@2x.png b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-5@2x.png
index 6fe731893..103c66fb5 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-5@2x.png and b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-5@2x.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-6.png b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-6.png
index 5d67dde98..44366ed78 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-6.png and b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-6.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-6@2x.png b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-6@2x.png
index fbdfbcabf..36df7cadd 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-6@2x.png and b/1-js/06-advanced-functions/03-closure/lexenv-nested-makecounter-6@2x.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexenv-nested-work.png b/1-js/06-advanced-functions/03-closure/lexenv-nested-work.png
index 5b1ab188b..3bdf5108d 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexenv-nested-work.png and b/1-js/06-advanced-functions/03-closure/lexenv-nested-work.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexenv-nested-work@2x.png b/1-js/06-advanced-functions/03-closure/lexenv-nested-work@2x.png
index 62e80de12..023dba05c 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexenv-nested-work@2x.png and b/1-js/06-advanced-functions/03-closure/lexenv-nested-work@2x.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexical-environment-global-2.png b/1-js/06-advanced-functions/03-closure/lexical-environment-global-2.png
index 47163aaa9..342bdae98 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexical-environment-global-2.png and b/1-js/06-advanced-functions/03-closure/lexical-environment-global-2.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexical-environment-global-2@2x.png b/1-js/06-advanced-functions/03-closure/lexical-environment-global-2@2x.png
index 240b01038..55306e666 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexical-environment-global-2@2x.png and b/1-js/06-advanced-functions/03-closure/lexical-environment-global-2@2x.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexical-environment-global-3.png b/1-js/06-advanced-functions/03-closure/lexical-environment-global-3.png
index b375e33d1..1cd77f8ac 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexical-environment-global-3.png and b/1-js/06-advanced-functions/03-closure/lexical-environment-global-3.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexical-environment-global-3@2x.png b/1-js/06-advanced-functions/03-closure/lexical-environment-global-3@2x.png
index cd22d06f4..3e256bbb9 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexical-environment-global-3@2x.png and b/1-js/06-advanced-functions/03-closure/lexical-environment-global-3@2x.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexical-environment-global.png b/1-js/06-advanced-functions/03-closure/lexical-environment-global.png
index c35f34917..6899a777f 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexical-environment-global.png and b/1-js/06-advanced-functions/03-closure/lexical-environment-global.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexical-environment-global@2x.png b/1-js/06-advanced-functions/03-closure/lexical-environment-global@2x.png
index 5aa9432b5..91980cf84 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexical-environment-global@2x.png and b/1-js/06-advanced-functions/03-closure/lexical-environment-global@2x.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexical-environment-simple-lookup.png b/1-js/06-advanced-functions/03-closure/lexical-environment-simple-lookup.png
index 067300455..56aafaf3d 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexical-environment-simple-lookup.png and b/1-js/06-advanced-functions/03-closure/lexical-environment-simple-lookup.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexical-environment-simple-lookup@2x.png b/1-js/06-advanced-functions/03-closure/lexical-environment-simple-lookup@2x.png
index 722aaba73..f423b125e 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexical-environment-simple-lookup@2x.png and b/1-js/06-advanced-functions/03-closure/lexical-environment-simple-lookup@2x.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexical-environment-simple.png b/1-js/06-advanced-functions/03-closure/lexical-environment-simple.png
index e6fd8b6ee..2424fbf23 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexical-environment-simple.png and b/1-js/06-advanced-functions/03-closure/lexical-environment-simple.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexical-environment-simple@2x.png b/1-js/06-advanced-functions/03-closure/lexical-environment-simple@2x.png
index 28e971b31..b206cbe8b 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexical-environment-simple@2x.png and b/1-js/06-advanced-functions/03-closure/lexical-environment-simple@2x.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexical-search-order.png b/1-js/06-advanced-functions/03-closure/lexical-search-order.png
index 392cb5712..1b641d48d 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexical-search-order.png and b/1-js/06-advanced-functions/03-closure/lexical-search-order.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexical-search-order@2x.png b/1-js/06-advanced-functions/03-closure/lexical-search-order@2x.png
index 870897d8d..f06bc3ed8 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexical-search-order@2x.png and b/1-js/06-advanced-functions/03-closure/lexical-search-order@2x.png differ
diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index cbf87d3cd..e32948b2b 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -11,7 +11,11 @@ Nei primi capitoli in cui abbiamo parlato di [variabili](info:variables), abbiam
 
 Invece `var` è totalmente diverso, poiché deriva dalle prime versioni del linguaggio. Generalmente negli script più recenti non viene utilizzato, ma appare ancora in quelli più vecchi.
 
+<<<<<<< HEAD
 Se non avete intenzione di avere a che fare con gli script più vecchi, potete saltare questo capitolo o studiarlo in futuro, ma molto probabilmente prima o poi vi ci imbatterete.
+=======
+If you don't plan on meeting such scripts you may even skip this chapter or postpone it, but then there's a chance that it bites you later.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 A prima vista, `var` si comporta in maniera analoga a `let`. Ad esempio:
 
@@ -74,7 +78,11 @@ sayHi();
 alert(phrase); // Errore: phrase non è definito
 ```
 
+<<<<<<< HEAD
 Come possiamo vedere, `var` passa attraverso `if`, `for` o altri blocchi di codice. Questo accade perché molto tempo fa i blocchi JavaScript non possedevano un Lexical Environments. E `var` ne è un ricordo.
+=======
+As we can see, `var` pierces through `if`, `for` or other code blocks. That's because a long time ago in JavaScript blocks had no Lexical Environments. And `var` is a remnant of that.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 ## "var" viene processata all'inizio della funzione
 
@@ -182,4 +190,8 @@ Ci sono due principali differenze con `var`:
 
 C'è un ulteriore differenza di minore importanza legata all'oggetto globale, che andremo ad analizzare nel prossimo capitolo.
 
+<<<<<<< HEAD
 L'insieme di queste differenze fa si che `var` venga considerato uno svantaggio. Come prima cosa, non possiamo creare delle variabili locali al blocco. Il "sollevameto" genera solamente confusione. Quindi, negli script più recenti `var` viene utilizzato solamente in casi eccezionali.
+=======
+These differences are actually a bad thing most of the time. Block-level variables is such a great thing. That's why `let` was introduced in the standard long ago, and is now a major way (along with `const`) to declare a variable.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/1-js/06-advanced-functions/05-global-object/article.md b/1-js/06-advanced-functions/05-global-object/article.md
index 0443eba98..da4adc2b6 100644
--- a/1-js/06-advanced-functions/05-global-object/article.md
+++ b/1-js/06-advanced-functions/05-global-object/article.md
@@ -1,171 +1,155 @@
 
-
 # Global object
 
-When JavaScript was created, there was an idea of a "global object" that provides all global variables and functions. It was planned that multiple in-browser scripts would use that single global object and share variables through it.
-
-Since then, JavaScript greatly evolved, and that idea of linking code through global variables became much less appealing. In modern JavaScript, the concept of modules took its place.
-
-But the global object still remains in the specification.
+The global object provides variables and functions that are available anywhere. Mostly, the ones that are built into the language or the host environment.
 
-In a browser it is named "window", for Node.JS it is "global", for other environments it may have another name.
+In a browser it is named "window", for Node.js it is "global", for other environments it may have another name.
 
-It does two things:
+For instance, we can call `alert` as a method of `window`:
 
-1. Provides access to built-in functions and values, defined by the specification and the environment.
-    For instance, we can call `alert` directly or as a method of `window`:
+```js run
+alert("Hello");
 
-    ```js run
-    alert("Hello");
-
-    // the same as
-    window.alert("Hello");
-    ```
+// the same as
+window.alert("Hello");
+```
 
-    The same applies to other built-ins. E.g. we can use `window.Array` instead of `Array`.
+We can reference other built-in functions like `Array` as `window.Array` and create our own properties on it.
 
-2. Provides access to global Function Declarations and `var` variables. We can read and write them using its properties, for instance:
+## Browser: the "window" object
 
-    <!-- no-strict to move variables out of eval -->
-    ```js untrusted run no-strict refresh
-    var phrase = "Hello";
+For historical reasons, in-browser `window` object is a bit messed up.
 
-    function sayHi() {
-      alert(phrase);
-    }
+1. It provides the "browser window" functionality, besides playing the role of a global object.
 
-    // can read from window
-    alert( window.phrase ); // Hello (global var)
-    alert( window.sayHi ); // function (global function declaration)
+    We can use `window` to access properties and methods, specific to the browser window:
 
-    // can write to window (creates a new global variable)
-    window.test = 5;
+    ```js run
+    alert(window.innerHeight); // shows the browser window height
 
-    alert(test); // 5
+    window.open('http://google.com'); // opens a new browser window
     ```
 
-...But the global object does not have variables declared with `let/const`!
+2. Top-level `var` variables and function declarations automatically become properties of `window`.
 
-```js untrusted run no-strict refresh
-*!*let*/!* user = "John";
-alert(user); // John
+    For instance:
+    ```js untrusted run no-strict refresh
+    var x = 5;
 
-alert(window.user); // undefined, don't have let
-alert("user" in window); // false
-```
+    alert(window.x); // 5 (var x becomes a property of window)
 
-```smart header="The global object is not a global Environment Record"
-In versions of ECMAScript prior to ES-2015, there were no `let/const` variables, only `var`. And global object was used as a global Environment Record (wordings were a bit different, but that's the gist).
+    window.x = 0;
 
-But starting from ES-2015, these entities are split apart. There's a global Lexical Environment with its Environment Record. And there's a global object that provides *some* of the global variables.
+    alert(x); // 0, variable modified
+    ```
 
-As a practical difference, global `let/const` variables are definitively properties of the global Environment Record, but they do not exist in the global object.
+    Please note, that doesn't happen with more modern `let/const` declarations:
 
-Naturally, that's because the idea of a global object as a way to access "all global things" comes from ancient times. Nowadays is not considered to be a good thing. Modern language features like `let/const` do not make friends with it, but old ones are still compatible.
-```
+    ```js untrusted run no-strict refresh
+    let x = 5;
 
-## Uses of "window"
+    alert(window.x); // undefined ("let" doesn't create a window property)
+    ```
 
-In server-side environments like Node.JS, the `global` object is used exceptionally rarely. Probably it would be fair to say "never".
+3. Also, all scripts share the same global scope, so variables declared in one `<script>` become visible in  another ones:
 
-In-browser `window` is sometimes used though.
+    ```html run
+    <script>
+      var a = 1;
+      let b = 2;
+    </script>
 
-Usually, it's not a good idea to use it, but here are some examples you can meet.
+    <script>
+      alert(a); // 1
+      alert(b); // 2
+    </script>
+    ```
 
-1. To access exactly the global variable if the function has the local one with the same name.
+4. And, a minor thing, but still: the value of `this` in the global scope is `window`.
 
     ```js untrusted run no-strict refresh
-    var user = "Global";
-
-    function sayHi() {
-      var user = "Local";
-
-    *!*
-      alert(window.user); // Global
-    */!*
-    }
-
-    sayHi();
+    alert(this); // window
     ```
 
-    Such use is a workaround. Would be better to name variables differently, that won't require use to write the code it this way. And please note `"var"` before `user`. The trick doesn't work with `let` variables.
+Why was it made like this? At the time of the language creation, the idea to merge multiple aspects into a single `window` object was to "make things simple". But since then many things changed. Tiny scripts became big applications that require proper architecture.
 
-2. To check if a certain global variable or a builtin exists.
+Is it good that different scripts (possibly from different sources) see variables of each other?
 
-    For instance, we want to check whether a global function `XMLHttpRequest` exists.
+No, it's not, because it may lead to naming conflicts: the same variable name can be used in two scripts for different purposes, so they will conflict with each other.
 
-    We can't write `if (XMLHttpRequest)`, because if there's no `XMLHttpRequest`, there will be an error (variable not defined).
+As of now, the multi-purpose `window` is considered a design mistake in the language.
 
-    But we can read it from `window.XMLHttpRequest`:
+Luckily, there's a "road out of hell", called "JavaScript modules".
 
-    ```js run
-    if (window.XMLHttpRequest) {
-      alert('XMLHttpRequest exists!')
-    }
-    ```
+If we set `type="module"` attribute on a `<script>` tag, then such script is considered a separate "module" with its own top-level scope (lexical environment), not interfering with `window`.
 
-    If there is no such global function then `window.XMLHttpRequest` is just a non-existing object property. That's `undefined`, no error, so it works.
+- In a module, `var x` does not become a property of `window`:
 
-    We can also write the test without `window`:
+    ```html run
+    <script type="module">
+      var x = 5;
 
-    ```js
-    if (typeof XMLHttpRequest == 'function') {
-      /* is there a function XMLHttpRequest? */
-    }
+      alert(window.x); // undefined
+    </script>
     ```
 
-    This doesn't use `window`, but is (theoretically) less reliable, because `typeof` may use a local XMLHttpRequest, and we want the global one.
+- Two modules that do not see variables of each other:
 
+    ```html run
+    <script type="module">
+      let x = 5;
+    </script>
 
-3. To take the variable from the right window. That's probably the most valid use case.
+    <script type="module">
+      alert(window.x); // undefined
+      alert(x); // Error: undeclared variable
+    </script>
+    ```
 
-    A browser may open multiple windows and tabs. A window may also embed another one in `<iframe>`. Every browser window has its own `window` object and global variables. JavaScript allows windows that come from the same site (same protocol, host, port) to access variables from each other.
+- And, the last minor thing, the top-level value of `this` in a module is `undefined` (why should it be `window` anyway?):
 
-    That use is a little bit beyond our scope for now, but it looks like:
     ```html run
-    <iframe src="/https/patch-diff.githubusercontent.com/" id="iframe"></iframe>
-
-    <script>
-      alert( innerWidth ); // get innerWidth property of the current window (browser only)
-      alert( Array ); // get Array of the current window (javascript core builtin)
-
-      // when the iframe loads...
-      iframe.onload = function() {
-        // get width of the iframe window
-      *!*
-        alert( iframe.contentWindow.innerWidth );
-      */!*
-        // get the builtin Array from the iframe window
-      *!*
-        alert( iframe.contentWindow.Array );
-      */!*
-      };
+    <script type="module">
+      alert(this); // undefined
     </script>
     ```
 
-    Here, first two alerts use the current window, and the latter two take variables from `iframe` window. Can be any variables if `iframe` originates from the same protocol/host/port.
+**Using `<script type="module">` fixes the design flaw of the language by separating top-level scope from `window`.**
+
+We'll cover more features of modules later, in the chapter [](info:modules).
 
-## "this" and global object
+## Valid uses of the global object
 
-Sometimes, the value of `this` is exactly the global object. That's rarely used, but some scripts rely on that.
+1. Using global variables is generally discouraged. There should be as few global variables as possible, but if we need to make something globally visible, we may want to put it into `window` (or `global` in Node.js).
 
-1. In the browser, the value of `this` in the global area is `window`:
+    Here we put the information about the current user into a global object, to be accessible from all other scripts:
 
     ```js run
-    // outside of functions
-    alert( this === window ); // true
+    // explicitly assign it to `window`
+    window.currentUser = {
+      name: "John",
+      age: 30
+    };
+
+    // then, elsewhere, in another script
+    alert(window.currentUser.name); // John
     ```
 
-    Other, non-browser environments, may use another value for `this` in such cases.
+2. We can test the global object for support of modern language features.
 
-2. When a function with `this` is called in non-strict mode, it gets the global object as `this`:
-    ```js run no-strict
-    // not in strict mode (!)
-    function f() {
-      alert(this); // [object Window]
+    For instance, test if a build-in `Promise` object exists (it doesn't in really old browsers):
+    ```js run
+    if (!window.Promise) {
+      alert("Your browser is really old!");
     }
+    ```
+
+3. We can create "polyfills": add functions that are not supported by the environment (say, an old browser), but exist in the modern standard.
 
-    f(); // called without an object
+    ```js run
+    if (!window.Promise) {
+      window.Promise = ... // custom implementation of the modern language feature
+    }
     ```
 
-    By specification, `this` in this case must be the global object, even in non-browser environments like Node.JS. That's for compatibility with old scripts, in strict mode `this` would be `undefined`.
+...And of course, if we're in a browser, using `window` to access browser window features (not as a global object) is completely fine.
diff --git a/1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/task.md b/1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/task.md
index e34bb67bb..0177c8f6e 100644
--- a/1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/task.md
+++ b/1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/task.md
@@ -8,7 +8,7 @@ Modify the code of `makeCounter()` so that the counter can also decrease and set
 
 - `counter()` should return the next number (as before).
 - `counter.set(value)` should set the `count` to `value`.
-- `counter.decrease(value)` should decrease the `count` by 1.
+- `counter.decrease()` should decrease the `count` by 1.
 
 See the sandbox code for the complete usage example.
 
diff --git a/1-js/06-advanced-functions/06-function-object/article.md b/1-js/06-advanced-functions/06-function-object/article.md
index f334f88bb..37839779c 100644
--- a/1-js/06-advanced-functions/06-function-object/article.md
+++ b/1-js/06-advanced-functions/06-function-object/article.md
@@ -153,7 +153,7 @@ alert( `Called ${sayHi.counter} times` ); // Called 2 times
 ```warn header="A property is not a variable"
 A property assigned to a function like `sayHi.counter = 0` does *not* define a local variable `counter` inside it. In other words, a property `counter` and a variable `let counter` are two unrelated things.
 
-We can treat a function as an object, store properties in it, but that has no effect on its execution. Variables never use function properties and vice versa. These are just parallel words.
+We can treat a function as an object, store properties in it, but that has no effect on its execution. Variables never use function properties and vice versa. These are just parallel worlds.
 ```
 
 Function properties can replace closures sometimes. For instance, we can rewrite the counter function example from the chapter <info:closure> to use a function property:
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/3-rewrite-settimeout/solution.md b/1-js/06-advanced-functions/08-settimeout-setinterval/3-rewrite-settimeout/solution.md
index 0183a4799..735a446f7 100644
--- a/1-js/06-advanced-functions/08-settimeout-setinterval/3-rewrite-settimeout/solution.md
+++ b/1-js/06-advanced-functions/08-settimeout-setinterval/3-rewrite-settimeout/solution.md
@@ -5,7 +5,7 @@ let i = 0;
 
 let start = Date.now();
 
-let timer = setInterval(count, 0);
+let timer = setInterval(count);
 
 function count() {
 
@@ -20,4 +20,3 @@ function count() {
 
 }
 ```
-
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/3-rewrite-settimeout/task.md b/1-js/06-advanced-functions/08-settimeout-setinterval/3-rewrite-settimeout/task.md
index 3c7881701..c3455c2a1 100644
--- a/1-js/06-advanced-functions/08-settimeout-setinterval/3-rewrite-settimeout/task.md
+++ b/1-js/06-advanced-functions/08-settimeout-setinterval/3-rewrite-settimeout/task.md
@@ -18,7 +18,7 @@ function count() {
   if (i == 1000000000) {
     alert("Done in " + (Date.now() - start) + 'ms');
   } else {
-    setTimeout(count, 0);
+    setTimeout(count);
   }
 
   // a piece of heavy job
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
index dfc08b77b..91310f383 100644
--- a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
+++ b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
@@ -7,7 +7,7 @@ There are two methods for it:
 - `setTimeout` allows to run a function once after the interval of time.
 - `setInterval` allows to run a function regularly with the interval between the runs.
 
-These methods are not a part of JavaScript specification. But most environments have the internal scheduler and provide these methods. In particular, they are supported in all browsers and Node.JS.
+These methods are not a part of JavaScript specification. But most environments have the internal scheduler and provide these methods. In particular, they are supported in all browsers and Node.js.
 
 
 ## setTimeout
@@ -15,7 +15,7 @@ These methods are not a part of JavaScript specification. But most environments
 The syntax:
 
 ```js
-let timerId = setTimeout(func|code, delay[, arg1, arg2...])
+let timerId = setTimeout(func|code, [delay], [arg1], [arg2], ...)
 ```
 
 Parameters:
@@ -25,7 +25,7 @@ Parameters:
 Usually, that's a function. For historical reasons, a string of code can be passed, but that's not recommended.
 
 `delay`
-: The delay before run, in milliseconds (1000 ms = 1 second).
+: The delay before run, in milliseconds (1000 ms = 1 second), by default 0.
 
 `arg1`, `arg2`...
 : Arguments for the function (not supported in IE9-)
@@ -99,7 +99,7 @@ clearTimeout(timerId);
 alert(timerId); // same identifier (doesn't become null after canceling)
 ```
 
-As we can see from `alert` output, in a browser the timer identifier is a number. In other environments, this can be something else. For instance, Node.JS returns a timer object with additional methods.
+As we can see from `alert` output, in a browser the timer identifier is a number. In other environments, this can be something else. For instance, Node.js returns a timer object with additional methods.
 
 Again, there is no universal specification for these methods, so that's fine.
 
@@ -110,7 +110,7 @@ For browsers, timers are described in the [timers section](https://www.w3.org/TR
 The `setInterval` method has the same syntax as `setTimeout`:
 
 ```js
-let timerId = setInterval(func|code, delay[, arg1, arg2...])
+let timerId = setInterval(func|code, [delay], [arg1], [arg2], ...)
 ```
 
 All arguments have the same meaning. But unlike `setTimeout` it runs the function not only once, but regularly after the given interval of time.
@@ -238,7 +238,7 @@ There's a side-effect. A function references the outer lexical environment, so,
 
 ## setTimeout(...,0)
 
-There's a special use case: `setTimeout(func, 0)`.
+There's a special use case: `setTimeout(func, 0)`, or just `setTimeout(func)`.
 
 This schedules the execution of `func` as soon as possible. But scheduler will invoke it only after the current code is complete.
 
@@ -247,7 +247,7 @@ So the function is scheduled to run "right after" the current code. In other wor
 For instance, this outputs "Hello", then immediately "World":
 
 ```js run
-setTimeout(() => alert("World"), 0);
+setTimeout(() => alert("World"));
 
 alert("Hello");
 ```
@@ -260,7 +260,7 @@ There's a trick to split CPU-hungry tasks using `setTimeout`.
 
 For instance, a syntax-highlighting script (used to colorize code examples on this page) is quite CPU-heavy. To highlight the code, it performs the analysis, creates many colored elements, adds them to the document -- for a big text that takes a lot. It may even cause the browser to "hang", which is unacceptable.
 
-So we can split the long text into pieces. First 100 lines, then plan another 100 lines using `setTimeout(...,0)`, and so on.
+So we can split the long text into pieces. First 100 lines, then plan another 100 lines using `setTimeout(..., 0)`, and so on.
 
 For clarity, let's take a simpler example for consideration. We have a function to count from `1` to `1000000000`.
 
@@ -303,7 +303,7 @@ function count() {
   if (i == 1e9) {
     alert("Done in " + (Date.now() - start) + 'ms');
   } else {
-    setTimeout(count, 0); // schedule the new call (**)
+    setTimeout(count); // schedule the new call (**)
   }
 
 }
@@ -338,7 +338,7 @@ function count() {
 
   // move the scheduling at the beginning
   if (i < 1e9 - 1e6) {
-    setTimeout(count, 0); // schedule the new call
+    setTimeout(count); // schedule the new call
   }
 
   do {
@@ -371,8 +371,8 @@ setTimeout(function run() {
   times.push(Date.now() - start); // remember delay from the previous call
 
   if (start + 100 < Date.now()) alert(times); // show the delays after 100ms
-  else setTimeout(run, 0); // else re-schedule
-}, 0);
+  else setTimeout(run); // else re-schedule
+});
 
 // an example of the output:
 // 1,1,1,1,9,15,20,24,30,35,40,45,50,55,59,64,70,75,80,85,90,95,100
@@ -382,7 +382,7 @@ First timers run immediately (just as written in the spec), and then the delay c
 
 That limitation comes from ancient times and many scripts rely on it, so it exists for historical reasons.
 
-For server-side JavaScript, that limitation does not exist, and there exist other ways to schedule an immediate asynchronous job, like [process.nextTick](https://nodejs.org/api/process.html) and [setImmediate](https://nodejs.org/api/timers.html) for Node.JS. So the notion is browser-specific only.
+For server-side JavaScript, that limitation does not exist, and there exist other ways to schedule an immediate asynchronous job, like [process.nextTick](https://nodejs.org/api/process.html) and [setImmediate](https://nodejs.org/api/timers.html) for Node.js. So the notion is browser-specific only.
 ````
 
 ### Allowing the browser to render
@@ -430,7 +430,7 @@ And if we use `setTimeout` to split it into pieces then changes are applied in-b
     } while (i % 1e3 != 0);
 
     if (i < 1e9) {
-      setTimeout(count, 0);
+      setTimeout(count);
     }
 
   }
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/setinterval-interval.png b/1-js/06-advanced-functions/08-settimeout-setinterval/setinterval-interval.png
index 060b2c293..844c53788 100644
Binary files a/1-js/06-advanced-functions/08-settimeout-setinterval/setinterval-interval.png and b/1-js/06-advanced-functions/08-settimeout-setinterval/setinterval-interval.png differ
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/setinterval-interval@2x.png b/1-js/06-advanced-functions/08-settimeout-setinterval/setinterval-interval@2x.png
index 4071849cd..4fbf122c5 100644
Binary files a/1-js/06-advanced-functions/08-settimeout-setinterval/setinterval-interval@2x.png and b/1-js/06-advanced-functions/08-settimeout-setinterval/setinterval-interval@2x.png differ
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/settimeout-interval.png b/1-js/06-advanced-functions/08-settimeout-setinterval/settimeout-interval.png
index 6c473a33c..f59e157fb 100644
Binary files a/1-js/06-advanced-functions/08-settimeout-setinterval/settimeout-interval.png and b/1-js/06-advanced-functions/08-settimeout-setinterval/settimeout-interval.png differ
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/settimeout-interval@2x.png b/1-js/06-advanced-functions/08-settimeout-setinterval/settimeout-interval@2x.png
index dd45e324f..ed99391cf 100644
Binary files a/1-js/06-advanced-functions/08-settimeout-setinterval/settimeout-interval@2x.png and b/1-js/06-advanced-functions/08-settimeout-setinterval/settimeout-interval@2x.png differ
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md
index 9ebb7abfc..a3843107c 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md
@@ -27,4 +27,4 @@ for (let args of work.calls) {
 }
 ```
 
-P.S. That decorator is sometimes useful for unit-testing, it's advanced form is `sinon.spy` in [Sinon.JS](http://sinonjs.org/) library.
+P.S. That decorator is sometimes useful for unit-testing. Its advanced form is `sinon.spy` in [Sinon.JS](http://sinonjs.org/) library.
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md b/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md
index 44b5024e1..24bb4d448 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md
@@ -1,6 +1,6 @@
 The solution:
 
-```js
+```js run demo
 function delay(f, ms) {
 
   return function() {
@@ -8,20 +8,25 @@ function delay(f, ms) {
   };
 
 }
+
+let f1000 = delay(alert, 1000);
+
+f1000("test"); // shows "test" after 1000ms
 ```
 
 Please note how an arrow function is used here. As we know, arrow functions do not have own `this` and `arguments`, so `f.apply(this, arguments)` takes `this` and `arguments` from the wrapper.
 
-If we pass a regular function, `setTimeout` would call it without arguments and `this=window` (in-browser), so we'd need to write a bit more code to pass them from the wrapper:
+If we pass a regular function, `setTimeout` would call it without arguments and `this=window` (assuming we're in the browser).
+
+We still can pass the right `this` by using an intermediate variable, but that's a little bit more cumbersome:
 
 ```js
 function delay(f, ms) {
 
-  // added variables to pass this and arguments from the wrapper inside setTimeout
   return function(...args) {
-    let savedThis = this;
+    let savedThis = this; // store this into an intermediate variable
     setTimeout(function() {
-      f.apply(savedThis, args);
+      f.apply(savedThis, args); // use it here
     }, ms);
   };
 
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/solution.md b/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/solution.md
index 1516aca35..4f5867ded 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/solution.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/solution.md
@@ -1,6 +1,4 @@
-
-
-```js run no-beautify
+```js demo
 function debounce(f, ms) {
 
   let isCooldown = false;
@@ -18,7 +16,7 @@ function debounce(f, ms) {
 }
 ```
 
-The call to `debounce` returns a wrapper. There may be two states:
+A call to `debounce` returns a wrapper. There may be two states:
 
 - `isCooldown = false` -- ready to run.
 - `isCooldown = true` -- waiting for the timeout.
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/solution.md b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/solution.md
index 372ebedd1..c844016d3 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/solution.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/solution.md
@@ -1,4 +1,4 @@
-```js
+```js demo
 function throttle(func, ms) {
 
   let isThrottled = false,
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md
index 547f336c5..716b4e1d6 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md
@@ -25,7 +25,7 @@ Visually, it will look like this:
 1. For the first mouse movement the decorated variant passes the call to `update`. That's important, the user sees our reaction to their move immediately.
 2. Then as the mouse moves on, until `100ms` nothing happens. The decorated variant ignores calls.
 3. At the end of `100ms` -- one more `update` happens with the last coordinates. 
-4. Then, finally, the mouse stops somewhere. The decorated variant waits until `100ms` expire and then runs `update` runs with last coordinates. So, perhaps the most important, the final mouse coordinates are processed.
+4. Then, finally, the mouse stops somewhere. The decorated variant waits until `100ms` expire and then runs `update` with last coordinates. So, perhaps the most important, the final mouse coordinates are processed.
 
 A code example:
 
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/article.md b/1-js/06-advanced-functions/09-call-apply-decorators/article.md
index 3f86b0d30..75c510d1e 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/article.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/article.md
@@ -305,7 +305,7 @@ If we look more closely, there's a minor difference between such uses of `call`
 
 So, these calls complement each other. Where we expect an iterable, `call` works, where we expect an array-like, `apply` works.
 
-And if `args` is both iterable and array-like, like a real array, then we technically could use any of them, but `apply` will probably be faster, because it's a single operation. Most JavaScript engines internally optimize is better than a pair `call + spread`.
+And if `args` is both iterable and array-like, like a real array, then we technically could use any of them, but `apply` will probably be faster, because it's a single operation. Most JavaScript engines internally optimize it better than a pair `call + spread`.
 
 One of the most important uses of `apply` is passing the call to another function, like this:
 
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/decorator-makecaching-wrapper.png b/1-js/06-advanced-functions/09-call-apply-decorators/decorator-makecaching-wrapper.png
index 171e27910..d9541c768 100644
Binary files a/1-js/06-advanced-functions/09-call-apply-decorators/decorator-makecaching-wrapper.png and b/1-js/06-advanced-functions/09-call-apply-decorators/decorator-makecaching-wrapper.png differ
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/decorator-makecaching-wrapper@2x.png b/1-js/06-advanced-functions/09-call-apply-decorators/decorator-makecaching-wrapper@2x.png
index 8d3b5434c..17eef3f18 100644
Binary files a/1-js/06-advanced-functions/09-call-apply-decorators/decorator-makecaching-wrapper@2x.png and b/1-js/06-advanced-functions/09-call-apply-decorators/decorator-makecaching-wrapper@2x.png differ
diff --git a/1-js/06-advanced-functions/10-bind/article.md b/1-js/06-advanced-functions/10-bind/article.md
index fdb07c608..aed139c1c 100644
--- a/1-js/06-advanced-functions/10-bind/article.md
+++ b/1-js/06-advanced-functions/10-bind/article.md
@@ -37,7 +37,7 @@ let f = user.sayHi;
 setTimeout(f, 1000); // lost user context
 ```
 
-The method `setTimeout` in-browser is a little special: it sets `this=window` for the function call (for Node.JS, `this` becomes the timer object, but doesn't really matter here). So for `this.firstName` it tries to get `window.firstName`, which does not exist. In other similar cases as we'll see, usually `this` just becomes `undefined`.
+The method `setTimeout` in-browser is a little special: it sets `this=window` for the function call (for Node.js, `this` becomes the timer object, but doesn't really matter here). So for `this.firstName` it tries to get `window.firstName`, which does not exist. In other similar cases as we'll see, usually `this` just becomes `undefined`.
 
 The task is quite typical -- we want to pass an object method somewhere else (here -- to the scheduler) where it will be called. How to make sure that it will be called in the right context?
 
diff --git a/1-js/06-advanced-functions/11-currying-partials/article.md b/1-js/06-advanced-functions/11-currying-partials/article.md
index e866f38a7..b97e6a5fc 100644
--- a/1-js/06-advanced-functions/11-currying-partials/article.md
+++ b/1-js/06-advanced-functions/11-currying-partials/article.md
@@ -28,6 +28,10 @@ function mul(a, b) {
 Let's use `bind` to create a function `double` on its base:
 
 ```js run
+function mul(a, b) {
+  return a * b;
+}
+
 *!*
 let double = mul.bind(null, 2);
 */!*
@@ -46,6 +50,10 @@ Please note that here we actually don't use `this` here. But `bind` requires it,
 The function `triple` in the code below triples the value:
 
 ```js run
+function mul(a, b) {
+  return a * b;
+}
+
 *!*
 let triple = mul.bind(null, 3);
 */!*
@@ -57,9 +65,9 @@ alert( triple(5) ); // = mul(3, 5) = 15
 
 Why do we usually make a partial function?
 
-Here our benefit is that we created an independent function with a readable name (`double`, `triple`). We can use it and don't write the first argument of every time, cause it's fixed with `bind`.
+The benefit is that we can create an independent function with a readable name (`double`, `triple`). We can use it and not provide first argument of every time as it's fixed with `bind`.
 
-In other cases, partial application is useful when we have a very generic function, and want a less universal variant of it for convenience.
+In other cases, partial application is useful when we have a very generic function and want a less universal variant of it for convenience.
 
 For instance, we have a function `send(from, to, text)`. Then, inside a `user` object we may want to use a partial variant of it: `sendTo(to, text)` that sends from the current user.
 
@@ -111,16 +119,18 @@ Also there's a ready [_.partial](https://lodash.com/docs#partial) implementation
 
 Sometimes people mix up partial function application mentioned above with another thing named "currying". That's another interesting technique of working with functions that we just have to mention here.
 
-[Currying](https://en.wikipedia.org/wiki/Currying) is translating a function from callable as `f(a, b, c)` into callable as `f(a)(b)(c)`.
+[Currying](https://en.wikipedia.org/wiki/Currying) is a transformation of functions that translates a function from callable as `f(a, b, c)` into callable as `f(a)(b)(c)`. In JavaScript, we usually make a wrapper to keep the original function.
 
-Let's make `curry` function that performs currying for binary functions. In other words, it translates `f(a, b)` into `f(a)(b)`:
+Currying doesn't call a function. It just transforms it.
+
+Let's create a helper `curry(f)` function that performs currying for a two-argument `f`. In other words, `curry(f)` for two-argument `f(a, b)` translates it into `f(a)(b)`
 
 ```js run
 *!*
-function curry(func) {
+function curry(f) { // curry(f) does the currying transform
   return function(a) {
     return function(b) {
-      return func(a, b);
+      return f(a, b);
     };
   };
 }
@@ -156,9 +166,11 @@ function curry(f) {
 
 ## Currying? What for?
 
-Advanced currying allows both to keep the function callable normally and to get partials easily. To understand the benefits we definitely need a worthy real-life example.
+To understand the benefits we definitely need a worthy real-life example.
 
-For instance, we have the logging function `log(date, importance, message)` that formats and outputs the information. In real projects such functions also have many other useful features like: sending it over the network or filtering:
+Advanced currying allows the function to be both callable normally and partially.
+
+For instance, we have the logging function `log(date, importance, message)` that formats and outputs the information. In real projects such functions also have many other useful features like sending logs over the network:
 
 ```js
 function log(date, importance, message) {
@@ -204,13 +216,15 @@ todayDebug("message"); // [HH:mm] DEBUG message
 
 So:
 1. We didn't lose anything after currying: `log` is still callable normally.
-2. We were able to generate partial functions that are convenient in many cases.
+2. We were able to generate partial functions such as for today's logs.
 
 ## Advanced curry implementation
 
-In case you're interested, here's the "advanced" curry implementation that we could use above.
+In case you'd like to get in details (not obligatory!), here's the "advanced" curry implementation that we could use above.
 
-```js run
+It's pretty short:
+
+```js
 function curry(func) {
 
   return function curried(...args) {
@@ -224,24 +238,23 @@ function curry(func) {
   };
 
 }
+```
 
+Usage examples:
+
+```js
 function sum(a, b, c) {
   return a + b + c;
 }
 
 let curriedSum = curry(sum);
 
-// still callable normally
-alert( curriedSum(1, 2, 3) ); // 6
-
-// get the partial with curried(1) and call it with 2 other arguments
-alert( curriedSum(1)(2,3) ); // 6
-
-// full curried form
-alert( curriedSum(1)(2)(3) ); // 6
+alert( curriedSum(1, 2, 3) ); // 6, still callable normally
+alert( curriedSum(1)(2,3) ); // 6, currying of 1st arg
+alert( curriedSum(1)(2)(3) ); // 6, full currying
 ```
 
-The new `curry` may look complicated, but it's actually pretty easy to understand.
+The new `curry` may look complicated, but it's actually easy to understand.
 
 The result of `curry(func)` is the wrapper `curried` that looks like this:
 
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/object-prototype-empty.png b/1-js/07-object-oriented-programming/03-prototype-inheritance/object-prototype-empty.png
deleted file mode 100644
index 1d228b5c8..000000000
Binary files a/1-js/07-object-oriented-programming/03-prototype-inheritance/object-prototype-empty.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/object-prototype-empty@2x.png b/1-js/07-object-oriented-programming/03-prototype-inheritance/object-prototype-empty@2x.png
deleted file mode 100644
index a4c195ad6..000000000
Binary files a/1-js/07-object-oriented-programming/03-prototype-inheritance/object-prototype-empty@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-chain.png b/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-chain.png
deleted file mode 100644
index a302343e2..000000000
Binary files a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-chain.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-chain@2x.png b/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-chain@2x.png
deleted file mode 100644
index 4d3311998..000000000
Binary files a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-chain@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk-2.png b/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk-2.png
deleted file mode 100644
index 19c1881a2..000000000
Binary files a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk-2.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk-2@2x.png b/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk-2@2x.png
deleted file mode 100644
index cd38624ab..000000000
Binary files a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk-2@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk-3.png b/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk-3.png
deleted file mode 100644
index 0ea869d3c..000000000
Binary files a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk-3.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk-3@2x.png b/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk-3@2x.png
deleted file mode 100644
index 194db77ed..000000000
Binary files a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk-3@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk.png b/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk.png
deleted file mode 100644
index 5bd211147..000000000
Binary files a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk@2x.png b/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk@2x.png
deleted file mode 100644
index 1e4ef6efb..000000000
Binary files a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit-walk@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit.png b/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit.png
deleted file mode 100644
index c18e02052..000000000
Binary files a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit@2x.png b/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit@2x.png
deleted file mode 100644
index 4d9e8ec09..000000000
Binary files a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-animal-rabbit@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-user-admin.png b/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-user-admin.png
deleted file mode 100644
index aed69c59e..000000000
Binary files a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-user-admin.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-user-admin@2x.png b/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-user-admin@2x.png
deleted file mode 100644
index 2b11b2568..000000000
Binary files a/1-js/07-object-oriented-programming/03-prototype-inheritance/proto-user-admin@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/function-prototype-constructor.png b/1-js/07-object-oriented-programming/04-function-prototype/function-prototype-constructor.png
deleted file mode 100644
index 0dbc7b8fc..000000000
Binary files a/1-js/07-object-oriented-programming/04-function-prototype/function-prototype-constructor.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/function-prototype-constructor@2x.png b/1-js/07-object-oriented-programming/04-function-prototype/function-prototype-constructor@2x.png
deleted file mode 100644
index e38cb85bd..000000000
Binary files a/1-js/07-object-oriented-programming/04-function-prototype/function-prototype-constructor@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/native-prototypes-array-tostring.png b/1-js/07-object-oriented-programming/04-function-prototype/native-prototypes-array-tostring.png
deleted file mode 100644
index 83258d061..000000000
Binary files a/1-js/07-object-oriented-programming/04-function-prototype/native-prototypes-array-tostring.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/native-prototypes-array-tostring@2x.png b/1-js/07-object-oriented-programming/04-function-prototype/native-prototypes-array-tostring@2x.png
deleted file mode 100644
index d77cc8f4e..000000000
Binary files a/1-js/07-object-oriented-programming/04-function-prototype/native-prototypes-array-tostring@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/native-prototypes-classes.png b/1-js/07-object-oriented-programming/04-function-prototype/native-prototypes-classes.png
deleted file mode 100644
index dbab2f78b..000000000
Binary files a/1-js/07-object-oriented-programming/04-function-prototype/native-prototypes-classes.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/native-prototypes-classes@2x.png b/1-js/07-object-oriented-programming/04-function-prototype/native-prototypes-classes@2x.png
deleted file mode 100644
index 8c3a18dc8..000000000
Binary files a/1-js/07-object-oriented-programming/04-function-prototype/native-prototypes-classes@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/object-prototype-1.png b/1-js/07-object-oriented-programming/04-function-prototype/object-prototype-1.png
deleted file mode 100644
index e7c6bdb21..000000000
Binary files a/1-js/07-object-oriented-programming/04-function-prototype/object-prototype-1.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/object-prototype-1@2x.png b/1-js/07-object-oriented-programming/04-function-prototype/object-prototype-1@2x.png
deleted file mode 100644
index 34c256bbf..000000000
Binary files a/1-js/07-object-oriented-programming/04-function-prototype/object-prototype-1@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/object-prototype.png b/1-js/07-object-oriented-programming/04-function-prototype/object-prototype.png
deleted file mode 100644
index d97d87d2c..000000000
Binary files a/1-js/07-object-oriented-programming/04-function-prototype/object-prototype.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/object-prototype@2x.png b/1-js/07-object-oriented-programming/04-function-prototype/object-prototype@2x.png
deleted file mode 100644
index 76ce4c9ac..000000000
Binary files a/1-js/07-object-oriented-programming/04-function-prototype/object-prototype@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/proto-constructor-animal-rabbit.png b/1-js/07-object-oriented-programming/04-function-prototype/proto-constructor-animal-rabbit.png
deleted file mode 100644
index 3eec740fb..000000000
Binary files a/1-js/07-object-oriented-programming/04-function-prototype/proto-constructor-animal-rabbit.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/proto-constructor-animal-rabbit@2x.png b/1-js/07-object-oriented-programming/04-function-prototype/proto-constructor-animal-rabbit@2x.png
deleted file mode 100644
index ed28a388a..000000000
Binary files a/1-js/07-object-oriented-programming/04-function-prototype/proto-constructor-animal-rabbit@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/rabbit-animal-object.png b/1-js/07-object-oriented-programming/04-function-prototype/rabbit-animal-object.png
deleted file mode 100644
index 3254270f3..000000000
Binary files a/1-js/07-object-oriented-programming/04-function-prototype/rabbit-animal-object.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/rabbit-animal-object@2x.png b/1-js/07-object-oriented-programming/04-function-prototype/rabbit-animal-object@2x.png
deleted file mode 100644
index f794d7b84..000000000
Binary files a/1-js/07-object-oriented-programming/04-function-prototype/rabbit-animal-object@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/rabbit-prototype-constructor.png b/1-js/07-object-oriented-programming/04-function-prototype/rabbit-prototype-constructor.png
deleted file mode 100644
index d3ef34485..000000000
Binary files a/1-js/07-object-oriented-programming/04-function-prototype/rabbit-prototype-constructor.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/rabbit-prototype-constructor@2x.png b/1-js/07-object-oriented-programming/04-function-prototype/rabbit-prototype-constructor@2x.png
deleted file mode 100644
index 45cbb6baa..000000000
Binary files a/1-js/07-object-oriented-programming/04-function-prototype/rabbit-prototype-constructor@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/function-prototype-constructor.png b/1-js/07-object-oriented-programming/05-native-prototypes/function-prototype-constructor.png
deleted file mode 100644
index 0dbc7b8fc..000000000
Binary files a/1-js/07-object-oriented-programming/05-native-prototypes/function-prototype-constructor.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/function-prototype-constructor@2x.png b/1-js/07-object-oriented-programming/05-native-prototypes/function-prototype-constructor@2x.png
deleted file mode 100644
index e38cb85bd..000000000
Binary files a/1-js/07-object-oriented-programming/05-native-prototypes/function-prototype-constructor@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/native-prototypes-array-tostring.png b/1-js/07-object-oriented-programming/05-native-prototypes/native-prototypes-array-tostring.png
deleted file mode 100644
index 83258d061..000000000
Binary files a/1-js/07-object-oriented-programming/05-native-prototypes/native-prototypes-array-tostring.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/native-prototypes-array-tostring@2x.png b/1-js/07-object-oriented-programming/05-native-prototypes/native-prototypes-array-tostring@2x.png
deleted file mode 100644
index d77cc8f4e..000000000
Binary files a/1-js/07-object-oriented-programming/05-native-prototypes/native-prototypes-array-tostring@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/native-prototypes-classes.png b/1-js/07-object-oriented-programming/05-native-prototypes/native-prototypes-classes.png
deleted file mode 100644
index dbab2f78b..000000000
Binary files a/1-js/07-object-oriented-programming/05-native-prototypes/native-prototypes-classes.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/native-prototypes-classes@2x.png b/1-js/07-object-oriented-programming/05-native-prototypes/native-prototypes-classes@2x.png
deleted file mode 100644
index 8c3a18dc8..000000000
Binary files a/1-js/07-object-oriented-programming/05-native-prototypes/native-prototypes-classes@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype-1.png b/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype-1.png
deleted file mode 100644
index e7c6bdb21..000000000
Binary files a/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype-1.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype-1@2x.png b/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype-1@2x.png
deleted file mode 100644
index 34c256bbf..000000000
Binary files a/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype-1@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype-null.png b/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype-null.png
deleted file mode 100644
index 7c2e3f9c7..000000000
Binary files a/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype-null.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype-null@2x.png b/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype-null@2x.png
deleted file mode 100644
index fec1facb0..000000000
Binary files a/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype-null@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype.png b/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype.png
deleted file mode 100644
index d97d87d2c..000000000
Binary files a/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype@2x.png b/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype@2x.png
deleted file mode 100644
index 76ce4c9ac..000000000
Binary files a/1-js/07-object-oriented-programming/05-native-prototypes/object-prototype@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/proto-constructor-animal-rabbit.png b/1-js/07-object-oriented-programming/05-native-prototypes/proto-constructor-animal-rabbit.png
deleted file mode 100644
index 3eec740fb..000000000
Binary files a/1-js/07-object-oriented-programming/05-native-prototypes/proto-constructor-animal-rabbit.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/proto-constructor-animal-rabbit@2x.png b/1-js/07-object-oriented-programming/05-native-prototypes/proto-constructor-animal-rabbit@2x.png
deleted file mode 100644
index ed28a388a..000000000
Binary files a/1-js/07-object-oriented-programming/05-native-prototypes/proto-constructor-animal-rabbit@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/rabbit-prototype-constructor.png b/1-js/07-object-oriented-programming/05-native-prototypes/rabbit-prototype-constructor.png
deleted file mode 100644
index d3ef34485..000000000
Binary files a/1-js/07-object-oriented-programming/05-native-prototypes/rabbit-prototype-constructor.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/rabbit-prototype-constructor@2x.png b/1-js/07-object-oriented-programming/05-native-prototypes/rabbit-prototype-constructor@2x.png
deleted file mode 100644
index 45cbb6baa..000000000
Binary files a/1-js/07-object-oriented-programming/05-native-prototypes/rabbit-prototype-constructor@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/06-prototype-methods/object-prototype-2.png b/1-js/07-object-oriented-programming/06-prototype-methods/object-prototype-2.png
deleted file mode 100644
index ee42f6b98..000000000
Binary files a/1-js/07-object-oriented-programming/06-prototype-methods/object-prototype-2.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/06-prototype-methods/object-prototype-2@2x.png b/1-js/07-object-oriented-programming/06-prototype-methods/object-prototype-2@2x.png
deleted file mode 100644
index 1917c6631..000000000
Binary files a/1-js/07-object-oriented-programming/06-prototype-methods/object-prototype-2@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/06-prototype-methods/object-prototype-null.png b/1-js/07-object-oriented-programming/06-prototype-methods/object-prototype-null.png
deleted file mode 100644
index 7c2e3f9c7..000000000
Binary files a/1-js/07-object-oriented-programming/06-prototype-methods/object-prototype-null.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/06-prototype-methods/object-prototype-null@2x.png b/1-js/07-object-oriented-programming/06-prototype-methods/object-prototype-null@2x.png
deleted file mode 100644
index fec1facb0..000000000
Binary files a/1-js/07-object-oriented-programming/06-prototype-methods/object-prototype-null@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/06-prototype-methods/rabbit-animal-object.png b/1-js/07-object-oriented-programming/06-prototype-methods/rabbit-animal-object.png
deleted file mode 100644
index 3254270f3..000000000
Binary files a/1-js/07-object-oriented-programming/06-prototype-methods/rabbit-animal-object.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/06-prototype-methods/rabbit-animal-object@2x.png b/1-js/07-object-oriented-programming/06-prototype-methods/rabbit-animal-object@2x.png
deleted file mode 100644
index f794d7b84..000000000
Binary files a/1-js/07-object-oriented-programming/06-prototype-methods/rabbit-animal-object@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/1-inheritance-error-assign/solution.md b/1-js/07-object-oriented-programming/08-class-patterns/1-inheritance-error-assign/solution.md
deleted file mode 100644
index 55f945ca5..000000000
--- a/1-js/07-object-oriented-programming/08-class-patterns/1-inheritance-error-assign/solution.md
+++ /dev/null
@@ -1,46 +0,0 @@
-Here's the line with the error:
-
-```js
-Rabbit.prototype = Animal.prototype;
-```
-
-Here `Rabbit.prototype` and `Animal.prototype` become the same object. So methods of both classes become mixed in that object.
-
-As a result, `Rabbit.prototype.walk` overwrites `Animal.prototype.walk`, so all animals start to bounce:
-
-```js run
-function Animal(name) {
-  this.name = name;
-}
-
-Animal.prototype.walk = function() {
-  alert(this.name + ' walks');
-};
-
-function Rabbit(name) {
-  this.name = name;
-}
-
-*!*
-Rabbit.prototype = Animal.prototype;
-*/!*
-
-Rabbit.prototype.walk = function() {
-  alert(this.name + " bounces!");
-};
-
-*!*
-let animal = new Animal("pig");
-animal.walk(); // pig bounces!
-*/!*
-```
-
-The correct variant would be:
-
-```js
-Rabbit.prototype.__proto__ = Animal.prototype;
-// or like this:
-Rabbit.prototype = Object.create(Animal.prototype);
-```
-
-That makes prototypes separate, each of them stores methods of the corresponding class, but `Rabbit.prototype` inherits from `Animal.prototype`.
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/1-inheritance-error-assign/task.md b/1-js/07-object-oriented-programming/08-class-patterns/1-inheritance-error-assign/task.md
deleted file mode 100644
index ee486c3d6..000000000
--- a/1-js/07-object-oriented-programming/08-class-patterns/1-inheritance-error-assign/task.md
+++ /dev/null
@@ -1,29 +0,0 @@
-importance: 5
-
----
-
-# An error in the inheritance
-
-Find an error in the prototypal inheritance below.
-
-What's wrong? What are consequences going to be?
-
-```js
-function Animal(name) {
-  this.name = name;
-}
-
-Animal.prototype.walk = function() {
-  alert(this.name + ' walks');
-};
-
-function Rabbit(name) {
-  this.name = name;
-}
-
-Rabbit.prototype = Animal.prototype;
-
-Rabbit.prototype.walk = function() {
-  alert(this.name + " bounces!");
-};
-```
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/solution.md b/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/solution.md
deleted file mode 100644
index 300b25d94..000000000
--- a/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/solution.md
+++ /dev/null
@@ -1 +0,0 @@
-Please note that properties that were internal in functional style (`template`, `timer`) and the internal method `render` are marked private with the underscore `_`.
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/solution.view/clock.js b/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/solution.view/clock.js
deleted file mode 100644
index c03634488..000000000
--- a/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/solution.view/clock.js
+++ /dev/null
@@ -1,32 +0,0 @@
-function Clock({ template }) {
-  this._template = template;
-}
-
-Clock.prototype._render = function() {
-  let date = new Date();
-
-  let hours = date.getHours();
-  if (hours < 10) hours = '0' + hours;
-
-  let mins = date.getMinutes();
-  if (mins < 10) mins = '0' + mins;
-
-  let secs = date.getSeconds();
-  if (secs < 10) secs = '0' + secs;
-
-  let output = this._template
-    .replace('h', hours)
-    .replace('m', mins)
-    .replace('s', secs);
-
-  console.log(output);
-};
-
-Clock.prototype.stop = function() {
-  clearInterval(this._timer);
-};
-
-Clock.prototype.start = function() {
-  this._render();
-  this._timer = setInterval(() => this._render(), 1000);
-};
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/solution.view/index.html b/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/solution.view/index.html
deleted file mode 100644
index fdee13d01..000000000
--- a/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/solution.view/index.html
+++ /dev/null
@@ -1,18 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-
-<head>
-  <title>Console clock</title>
-  <meta charset="utf-8">
-</head>
-
-<body>
-
-  <script src="clock.js"></script>
-  <script>
-    let clock = new Clock({template: 'h:m:s'});
-    clock.start();
-  </script>
-
-</body>
-</html>
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/source.view/index.html b/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/source.view/index.html
deleted file mode 100644
index fdee13d01..000000000
--- a/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/source.view/index.html
+++ /dev/null
@@ -1,18 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-
-<head>
-  <title>Console clock</title>
-  <meta charset="utf-8">
-</head>
-
-<body>
-
-  <script src="clock.js"></script>
-  <script>
-    let clock = new Clock({template: 'h:m:s'});
-    clock.start();
-  </script>
-
-</body>
-</html>
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/task.md b/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/task.md
deleted file mode 100644
index 71131816b..000000000
--- a/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/task.md
+++ /dev/null
@@ -1,9 +0,0 @@
-importance: 5
-
----
-
-# Rewrite to prototypes
-
-The `Clock` class is written in functional style. Rewrite it using prototypes.
-
-P.S. The clock ticks in the console, open it to see.
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/article.md b/1-js/07-object-oriented-programming/08-class-patterns/article.md
deleted file mode 100644
index 92b521c19..000000000
--- a/1-js/07-object-oriented-programming/08-class-patterns/article.md
+++ /dev/null
@@ -1,240 +0,0 @@
-
-# Class patterns
-
-```quote author="Wikipedia"
-In object-oriented programming, a *class* is an extensible program-code-template for creating objects, providing initial values for state (member variables) and implementations of behavior (member functions or methods).
-```
-
-There's a special syntax construct and a keyword `class` in JavaScript. But before studying it, we should consider that the term "class" comes from the theory of object-oriented programming. The definition is cited above, and it's language-independent.
-
-In JavaScript there are several well-known programming patterns to make classes even without using the `class` keyword. And here we'll talk about them first.
-
-The `class` construct will be described in the next chapter, but in JavaScript it's a "syntax sugar" and an extension of one of the patterns that we'll study here.
-
-
-## Functional class pattern
-
-The constructor function below can be considered a "class" according to the definition:
-
-```js run
-function User(name) {
-  this.sayHi = function() {
-    alert(name);
-  };
-}
-
-let user = new User("John");
-user.sayHi(); // John
-```
-
-It follows all parts of the definition:
-
-1. It is a "program-code-template" for creating objects (callable with `new`).
-2. It provides initial values for the state (`name` from parameters).
-3. It provides methods (`sayHi`).
-
-This is called *functional class pattern*.
-
-In the functional class pattern, local variables and nested functions inside `User`, that are not assigned to `this`, are visible from inside, but not accessible by the outer code.
-
-So we can easily add internal functions and variables, like `calcAge()` here:
-
-```js run
-function User(name, birthday) {
-*!*
-  // only visible from other methods inside User
-  function calcAge() {
-    return new Date().getFullYear() - birthday.getFullYear();
-  }
-*/!*
-
-  this.sayHi = function() {
-    alert(`${name}, age:${calcAge()}`);
-  };
-}
-
-let user = new User("John", new Date(2000, 0, 1));
-user.sayHi(); // John, age:17
-```
-
-In this code variables `name`, `birthday` and the function `calcAge()` are internal, *private* to the object. They are only visible from inside of it.
-
-On the other hand, `sayHi` is the external, *public* method. The external code that creates `user` can access it.
-
-This way we can hide internal implementation details and helper methods from the outer code. Only what's assigned to `this` becomes visible outside.
-
-## Factory class pattern
-
-We can create a class without using `new` at all.
-
-Like this:
-
-```js run
-function User(name, birthday) {
-  // only visible from other methods inside User
-  function calcAge() {
-    return new Date().getFullYear() - birthday.getFullYear();
-  }
-
-  return {
-    sayHi() {
-      alert(`${name}, age:${calcAge()}`);
-    }
-  };
-}
-
-*!*
-let user = User("John", new Date(2000, 0, 1));
-*/!*
-user.sayHi(); // John, age:17
-```
-
-As we can see, the function `User` returns an object with public properties and methods. The only benefit of this method is that we can omit `new`: write `let user = User(...)` instead of `let user = new User(...)`. In other aspects it's almost the same as the functional pattern.
-
-## Prototype-based classes
-
-Prototype-based classes are the most important and generally the best. Functional and factory class patterns are rarely used in practice.
-
-Soon you'll see why.
-
-Here's the same class rewritten using prototypes:
-
-```js run
-function User(name, birthday) {
-*!*
-  this._name = name;
-  this._birthday = birthday;
-*/!*
-}
-
-*!*
-User.prototype._calcAge = function() {
-*/!*
-  return new Date().getFullYear() - this._birthday.getFullYear();
-};
-
-User.prototype.sayHi = function() {
-  alert(`${this._name}, age:${this._calcAge()}`);
-};
-
-let user = new User("John", new Date(2000, 0, 1));
-user.sayHi(); // John, age:17
-```
-
-The code structure:
-
-- The constructor `User` only initializes the current object state.
-- Methods are added to `User.prototype`.
-
-As we can see, methods are lexically not inside `function User`, they do not share a common lexical environment. If we declare variables inside `function User`, then they won't be visible to methods.
-
-So, there is a widely known agreement that internal properties and methods are prepended with an underscore `"_"`. Like `_name` or `_calcAge()`. Technically, that's just an agreement, the outer code still can access them. But most developers recognize the meaning of `"_"` and try not to touch prefixed properties and methods in the external code.
-
-Here are the advantages over the functional pattern:
-
-- In the functional pattern, each object has its own copy of every method. We assign a separate copy of `this.sayHi = function() {...}` and other methods in the constructor.
-- In the prototypal pattern, all methods are in `User.prototype` that is shared between all user objects. An object itself only stores the data.
-
-So the prototypal pattern is more memory-efficient.
-
-...But not only that. Prototypes allow us to setup the inheritance in a really efficient way. Built-in JavaScript objects all use prototypes. Also there's a special syntax construct: "class" that provides nice-looking syntax for them. And there's more, so let's go on with them.
-
-## Prototype-based inheritance for classes
-
-Let's say we have two prototype-based classes.
-
-`Rabbit`:
-
-```js
-function Rabbit(name) {
-  this.name = name;
-}
-
-Rabbit.prototype.jump = function() {
-  alert(`${this.name} jumps!`);
-};
-
-let rabbit = new Rabbit("My rabbit");
-```
-
-![](rabbit-animal-independent-1.png)
-
-...And `Animal`:
-
-```js
-function Animal(name) {
-  this.name = name;
-}
-
-Animal.prototype.eat = function() {
-  alert(`${this.name} eats.`);
-};
-
-let animal = new Animal("My animal");
-```
-
-![](rabbit-animal-independent-2.png)
-
-Right now they are fully independent.
-
-But we'd want `Rabbit` to extend `Animal`. In other words, rabbits should be based on animals, have access to methods of `Animal` and extend them with its own methods.
-
-What does it mean in the language of prototypes?
-
-Right now methods for `rabbit` objects are in `Rabbit.prototype`. We'd like `rabbit` to use `Animal.prototype` as a "fallback", if the method is not found in `Rabbit.prototype`.
-
-So the prototype chain should be `rabbit` -> `Rabbit.prototype` -> `Animal.prototype`.
-
-Like this:
-
-![](class-inheritance-rabbit-animal.png)
-
-The code to implement that:
-
-```js run
-// Same Animal as before
-function Animal(name) {
-  this.name = name;
-}
-
-// All animals can eat, right?
-Animal.prototype.eat = function() {
-  alert(`${this.name} eats.`);
-};
-
-// Same Rabbit as before
-function Rabbit(name) {
-  this.name = name;
-}
-
-Rabbit.prototype.jump = function() {
-  alert(`${this.name} jumps!`);
-};
-
-*!*
-// setup the inheritance chain
-Rabbit.prototype.__proto__ = Animal.prototype; // (*)
-*/!*
-
-let rabbit = new Rabbit("White Rabbit");
-*!*
-rabbit.eat(); // rabbits can eat too
-*/!*
-rabbit.jump();
-```
-
-The line `(*)` sets up the prototype chain. So that `rabbit` first searches methods in `Rabbit.prototype`, then `Animal.prototype`. And then, just for completeness, let's mention that if the method is not found in `Animal.prototype`, then the search continues in `Object.prototype`, because `Animal.prototype` is a regular plain object, so it inherits from it.
-
-So here's the full picture:
-
-![](class-inheritance-rabbit-animal-2.png)
-
-## Summary
-
-The term "class" comes from the object-oriented programming. In JavaScript it usually means the functional class pattern or the prototypal pattern. The prototypal pattern is more powerful and memory-efficient, so it's recommended to stick to it.
-
-According to the prototypal pattern:
-1. Methods are stored in `Class.prototype`.
-2. Prototypes inherit from each other.
-
-In the next chapter we'll study `class` keyword and construct. It allows to write prototypal classes shorter and provides some additional benefits.
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/class-inheritance-rabbit-animal-2.png b/1-js/07-object-oriented-programming/08-class-patterns/class-inheritance-rabbit-animal-2.png
deleted file mode 100644
index ad4a40932..000000000
Binary files a/1-js/07-object-oriented-programming/08-class-patterns/class-inheritance-rabbit-animal-2.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/class-inheritance-rabbit-animal-2@2x.png b/1-js/07-object-oriented-programming/08-class-patterns/class-inheritance-rabbit-animal-2@2x.png
deleted file mode 100644
index 199ed3ee6..000000000
Binary files a/1-js/07-object-oriented-programming/08-class-patterns/class-inheritance-rabbit-animal-2@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/class-inheritance-rabbit-animal.png b/1-js/07-object-oriented-programming/08-class-patterns/class-inheritance-rabbit-animal.png
deleted file mode 100644
index 70708c284..000000000
Binary files a/1-js/07-object-oriented-programming/08-class-patterns/class-inheritance-rabbit-animal.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/class-inheritance-rabbit-animal@2x.png b/1-js/07-object-oriented-programming/08-class-patterns/class-inheritance-rabbit-animal@2x.png
deleted file mode 100644
index 0db130181..000000000
Binary files a/1-js/07-object-oriented-programming/08-class-patterns/class-inheritance-rabbit-animal@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-1.png b/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-1.png
deleted file mode 100644
index e63d7d784..000000000
Binary files a/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-1.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-1@2x.png b/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-1@2x.png
deleted file mode 100644
index 3d1be9cce..000000000
Binary files a/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-1@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-2.png b/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-2.png
deleted file mode 100644
index 435ec5f89..000000000
Binary files a/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-2.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-2@2x.png b/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-2@2x.png
deleted file mode 100644
index 5731da73a..000000000
Binary files a/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-2@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/solution.view/index.html b/1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/solution.view/index.html
deleted file mode 100644
index fdee13d01..000000000
--- a/1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/solution.view/index.html
+++ /dev/null
@@ -1,18 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-
-<head>
-  <title>Console clock</title>
-  <meta charset="utf-8">
-</head>
-
-<body>
-
-  <script src="clock.js"></script>
-  <script>
-    let clock = new Clock({template: 'h:m:s'});
-    clock.start();
-  </script>
-
-</body>
-</html>
diff --git a/1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/source.view/clock.js b/1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/source.view/clock.js
deleted file mode 100644
index d312c93ea..000000000
--- a/1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/source.view/clock.js
+++ /dev/null
@@ -1,34 +0,0 @@
-
-
-function Clock({ template }) {
-  this._template = template;
-}
-
-Clock.prototype._render = function() {
-  let date = new Date();
-
-  let hours = date.getHours();
-  if (hours < 10) hours = '0' + hours;
-
-  let mins = date.getMinutes();
-  if (mins < 10) mins = '0' + mins;
-
-  let secs = date.getSeconds();
-  if (secs < 10) secs = '0' + secs;
-
-  let output = this._template
-    .replace('h', hours)
-    .replace('m', mins)
-    .replace('s', secs);
-
-  console.log(output);
-};
-
-Clock.prototype.stop = function() {
-  clearInterval(this._timer);
-};
-
-Clock.prototype.start = function() {
-  this._render();
-  this._timer = setInterval(() => this._render(), 1000);
-};
diff --git a/1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/source.view/index.html b/1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/source.view/index.html
deleted file mode 100644
index fdee13d01..000000000
--- a/1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/source.view/index.html
+++ /dev/null
@@ -1,18 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-
-<head>
-  <title>Console clock</title>
-  <meta charset="utf-8">
-</head>
-
-<body>
-
-  <script src="clock.js"></script>
-  <script>
-    let clock = new Clock({template: 'h:m:s'});
-    clock.start();
-  </script>
-
-</body>
-</html>
diff --git a/1-js/07-object-oriented-programming/09-class/article.md b/1-js/07-object-oriented-programming/09-class/article.md
deleted file mode 100644
index 71878ae35..000000000
--- a/1-js/07-object-oriented-programming/09-class/article.md
+++ /dev/null
@@ -1,355 +0,0 @@
-
-# Classes
-
-The "class" construct allows to define prototype-based classes with a clean, nice-looking syntax.
-
-## The "class" syntax
-
-The `class` syntax is versatile, we'll start with a simple example first.
-
-Here's a prototype-based class `User`:
-
-```js run
-function User(name) {
-  this.name = name;
-}
-
-User.prototype.sayHi = function() {
-  alert(this.name);
-}
-
-let user = new User("John");
-user.sayHi();
-```
-
-...And that's the same using `class` syntax:
-
-```js run
-class User {
-
-  constructor(name) {
-    this.name = name;
-  }
-
-  sayHi() {
-    alert(this.name);
-  }
-
-}
-
-let user = new User("John");
-user.sayHi();
-```
-
-It's easy to see that the two examples are alike. Just please note that methods in a class do not have a comma between them. Novice developers sometimes forget it and put a comma between class methods, and things don't work. That's not a literal object, but a class syntax.
-
-So, what exactly does `class` do? We may think that it defines a new language-level entity, but that would be wrong.
-
-The `class User {...}` here actually does two things:
-
-1. Declares a variable `User` that references the function named `"constructor"`.
-2. Puts methods listed in the definition into `User.prototype`. Here, it includes `sayHi` and the `constructor`.
-
-Here's the code to dig into the class and see that:
-
-```js run
-class User {
-  constructor(name) { this.name = name; }
-  sayHi() { alert(this.name); }
-}
-
-*!*
-// proof: User is the "constructor" function
-*/!*
-alert(User === User.prototype.constructor); // true
-
-*!*
-// proof: there are two methods in its "prototype"
-*/!*
-alert(Object.getOwnPropertyNames(User.prototype)); // constructor, sayHi
-```
-
-Here's the illustration of what `class User` creates:
-
-![](class-user.png)
-
-
-
-So `class` is a special syntax to define a constructor together with its prototype methods.
-
-...But not only that. There are minor tweaks here and there:
-
-Constructors require `new`
-: Unlike a regular function, a class `constructor` can't be called without `new`:
-
-```js run
-class User {
-  constructor() {}
-}
-
-alert(typeof User); // function
-User(); // Error: Class constructor User cannot be invoked without 'new'
-```
-
-Different string output
-: If we output it like `alert(User)`, some engines show `"class User..."`, while others show `"function User..."`.
-
-Please don't be confused: the string representation may vary, but that's still a function, there is no separate "class" entity in JavaScript language.
-
-Class methods are non-enumerable
-: A class definition sets `enumerable` flag to `false` for all methods in the `"prototype"`. That's good, because if we `for..in` over an object, we usually don't want its class methods.
-
-Classes have a default `constructor() {}`
-: If there's no `constructor` in the `class` construct, then an empty function is generated, same as if we had written `constructor() {}`.
-
-Classes always `use strict`
-: All code inside the class construct is automatically in strict mode.
-
-### Getters/setters
-
-Classes may also include getters/setters. Here's an example with `user.name` implemented using them:
-
-```js run
-class User {
-
-  constructor(name) {
-    // invokes the setter
-    this.name = name;
-  }
-
-*!*
-  get name() {
-*/!*
-    return this._name;
-  }
-
-*!*
-  set name(value) {
-*/!*
-    if (value.length < 4) {
-      alert("Name is too short.");
-      return;
-    }
-    this._name = value;
-  }
-
-}
-
-let user = new User("John");
-alert(user.name); // John
-
-user = new User(""); // Name too short.
-```
-
-Internally, getters and setters are also created on the `User` prototype, like this:
-
-```js
-Object.defineProperties(User.prototype, {
-  name: {
-    get() {
-      return this._name
-    },
-    set(name) {
-      // ...
-    }
-  }
-});
-```
-
-### Only methods
-
-Unlike object literals, no `property:value` assignments are allowed inside `class`. There may be only methods and getters/setters. There is some work going on in the specification to lift that limitation, but it's not yet there.
-
-If we really need to put a non-function value into the prototype, then we can alter `prototype` manually, like this:
-
-```js run
-class User { }
-
-User.prototype.test = 5;
-
-alert( new User().test ); // 5
-```
-
-So, technically that's possible, but we should know why we're doing it. Such properties will be shared among all objects of the class.
-
-An "in-class" alternative is to use a getter:
-
-```js run
-class User {
-  get test() {
-    return 5;
-  }
-}
-
-alert( new User().test ); // 5
-```
-
-From the external code, the usage is the same. But the getter variant is a bit slower.
-
-## Class Expression
-
-Just like functions, classes can be defined inside another expression, passed around, returned etc.
-
-Here's a class-returning function ("class factory"):
-
-```js run
-function makeClass(phrase) {
-*!*
-  // declare a class and return it
-  return class {
-    sayHi() {
-      alert(phrase);
-    };
-  };
-*/!*
-}
-
-let User = makeClass("Hello");
-
-new User().sayHi(); // Hello
-```
-
-That's quite normal if we recall that `class` is just a special form of a function-with-prototype definition.
-
-And, like Named Function Expressions, such classes also may have a name, that is visible inside that class only:
-
-```js run
-// "Named Class Expression" (alas, no such term, but that's what's going on)
-let User = class *!*MyClass*/!* {
-  sayHi() {
-    alert(MyClass); // MyClass is visible only inside the class
-  }
-};
-
-new User().sayHi(); // works, shows MyClass definition
-
-alert(MyClass); // error, MyClass not visible outside of the class
-```
-
-## Static methods
-
-We can also assign methods to the class function, not to its `"prototype"`. Such methods are called *static*.
-
-An example:
-
-```js run
-class User {
-*!*
-  static staticMethod() {
-*/!*
-    alert(this === User);
-  }
-}
-
-User.staticMethod(); // true
-```
-
-That actually does the same as assigning it as a function property:
-
-```js
-function User() { }
-
-User.staticMethod = function() {
-  alert(this === User);
-};
-```
-
-The value of `this` inside `User.staticMethod()` is the class constructor `User` itself (the "object before dot" rule).
-
-Usually, static methods are used to implement functions that belong to the class, but not to any particular object of it.
-
-For instance, we have `Article` objects and need a function to compare them. The natural choice would be `Article.compare`, like this:
-
-```js run
-class Article {
-  constructor(title, date) {
-    this.title = title;
-    this.date = date;
-  }
-
-*!*
-  static compare(articleA, articleB) {
-    return articleA.date - articleB.date;
-  }
-*/!*
-}
-
-// usage
-let articles = [
-  new Article("Mind", new Date(2016, 1, 1)),
-  new Article("Body", new Date(2016, 0, 1)),
-  new Article("JavaScript", new Date(2016, 11, 1))
-];
-
-*!*
-articles.sort(Article.compare);
-*/!*
-
-alert( articles[0].title ); // Body
-```
-
-Here `Article.compare` stands "over" the articles, as a means to compare them. It's not a method of an article, but rather of the whole class.
-
-Another example would be a so-called "factory" method. Imagine, we need few ways to create an article:
-
-1. Create by given parameters (`title`, `date` etc).
-2. Create an empty article with today's date.
-3. ...
-
-The first way can be implemented by the constructor. And for the second one we can make a static method of the class.
-
-Like `Article.createTodays()` here:
-
-```js run
-class Article {
-  constructor(title, date) {
-    this.title = title;
-    this.date = date;
-  }
-
-*!*
-  static createTodays() {
-    // remember, this = Article
-    return new this("Today's digest", new Date());
-  }
-*/!*
-}
-
-let article = Article.createTodays();
-
-alert( article.title ); // Todays digest
-```
-
-Now every time we need to create a today's digest, we can call `Article.createTodays()`. Once again, that's not a method of an article, but a method of the whole class.
-
-Static methods are also used in database-related classes to search/save/remove entries from the database, like this:
-
-```js
-// assuming Article is a special class for managing articles
-// static method to remove the article:
-Article.remove({id: 12345});
-```
-
-## Summary
-
-The basic class syntax looks like this:
-
-```js
-class MyClass {
-  constructor(...) {
-    // ...
-  }
-  method1(...) {}
-  method2(...) {}
-  get something(...) {}
-  set something(...) {}
-  static staticMethod(..) {}
-  // ...
-}
-```
-
-The value of `MyClass` is a function provided as `constructor`. If there's no `constructor`, then an empty function.
-
-In any case, methods listed in the class declaration become members of its `prototype`, with the exception of static methods that are written into the function itself and callable as `MyClass.staticMethod()`. Static methods are used when we need a function bound to a class, but not to any object of that class.
-
-In the next chapter we'll learn more about classes, including inheritance.
diff --git a/1-js/07-object-oriented-programming/09-class/class-user.png b/1-js/07-object-oriented-programming/09-class/class-user.png
deleted file mode 100644
index 5579e6bbd..000000000
Binary files a/1-js/07-object-oriented-programming/09-class/class-user.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/09-class/class-user@2x.png b/1-js/07-object-oriented-programming/09-class/class-user@2x.png
deleted file mode 100644
index 5a85e6589..000000000
Binary files a/1-js/07-object-oriented-programming/09-class/class-user@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/solution.view/index.html b/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/solution.view/index.html
deleted file mode 100644
index 7ac1db714..000000000
--- a/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/solution.view/index.html
+++ /dev/null
@@ -1,23 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-
-<head>
-  <title>Console clock</title>
-</head>
-
-<body>
-
-  <script src="clock.js"></script>
-  <script src="extended-clock.js"></script>
-
-  <script>
-    let lowResolutionClock = new ExtendedClock({
-      template: 'h:m:s',
-      precision: 10000
-    });
-
-    lowResolutionClock.start();
-  </script>
-
-</body>
-</html>
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/source.view/index.html b/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/source.view/index.html
deleted file mode 100644
index b48a2a007..000000000
--- a/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/source.view/index.html
+++ /dev/null
@@ -1,34 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-
-<head>
-  <title>Console clock</title>
-</head>
-
-<body>
-
-  <!-- source clock -->
-  <script src="clock.js"></script>
-  <script>
-    let clock = new Clock({
-      template: 'h:m:s'
-    });
-    clock.start();
-
-
-    /* Your class should work like this: */
-
-    /*
-
-      let lowResolutionClock = new ExtendedClock({
-        template: 'h:m:s',
-        precision: 10000
-      });
-
-      lowResolutionClock.start();
-    */
-  </script>
-
-</body>
-
-</html>
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/rabbit-extends-object.png b/1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/rabbit-extends-object.png
deleted file mode 100644
index d4ff37e56..000000000
Binary files a/1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/rabbit-extends-object.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/rabbit-extends-object@2x.png b/1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/rabbit-extends-object@2x.png
deleted file mode 100644
index a54a9d2f8..000000000
Binary files a/1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/rabbit-extends-object@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/animal-rabbit-extends.png b/1-js/07-object-oriented-programming/10-class-inheritance/animal-rabbit-extends.png
deleted file mode 100644
index 2db88f366..000000000
Binary files a/1-js/07-object-oriented-programming/10-class-inheritance/animal-rabbit-extends.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/animal-rabbit-extends@2x.png b/1-js/07-object-oriented-programming/10-class-inheritance/animal-rabbit-extends@2x.png
deleted file mode 100644
index 9539fe9ec..000000000
Binary files a/1-js/07-object-oriented-programming/10-class-inheritance/animal-rabbit-extends@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/animal-rabbit-static.png b/1-js/07-object-oriented-programming/10-class-inheritance/animal-rabbit-static.png
deleted file mode 100644
index 998c82330..000000000
Binary files a/1-js/07-object-oriented-programming/10-class-inheritance/animal-rabbit-static.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/animal-rabbit-static@2x.png b/1-js/07-object-oriented-programming/10-class-inheritance/animal-rabbit-static@2x.png
deleted file mode 100644
index 98a80d38f..000000000
Binary files a/1-js/07-object-oriented-programming/10-class-inheritance/animal-rabbit-static@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/class-inheritance-array-object.png b/1-js/07-object-oriented-programming/10-class-inheritance/class-inheritance-array-object.png
deleted file mode 100644
index c5d712632..000000000
Binary files a/1-js/07-object-oriented-programming/10-class-inheritance/class-inheritance-array-object.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/class-inheritance-array-object@2x.png b/1-js/07-object-oriented-programming/10-class-inheritance/class-inheritance-array-object@2x.png
deleted file mode 100644
index edc4e841e..000000000
Binary files a/1-js/07-object-oriented-programming/10-class-inheritance/class-inheritance-array-object@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/class-inheritance-rabbit-animal.png b/1-js/07-object-oriented-programming/10-class-inheritance/class-inheritance-rabbit-animal.png
deleted file mode 100644
index 70708c284..000000000
Binary files a/1-js/07-object-oriented-programming/10-class-inheritance/class-inheritance-rabbit-animal.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/class-inheritance-rabbit-animal@2x.png b/1-js/07-object-oriented-programming/10-class-inheritance/class-inheritance-rabbit-animal@2x.png
deleted file mode 100644
index 0db130181..000000000
Binary files a/1-js/07-object-oriented-programming/10-class-inheritance/class-inheritance-rabbit-animal@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/object-date-inheritance.png b/1-js/07-object-oriented-programming/10-class-inheritance/object-date-inheritance.png
deleted file mode 100644
index 542a0c9fa..000000000
Binary files a/1-js/07-object-oriented-programming/10-class-inheritance/object-date-inheritance.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/object-date-inheritance@2x.png b/1-js/07-object-oriented-programming/10-class-inheritance/object-date-inheritance@2x.png
deleted file mode 100644
index 21485062a..000000000
Binary files a/1-js/07-object-oriented-programming/10-class-inheritance/object-date-inheritance@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/this-super-loop.png b/1-js/07-object-oriented-programming/10-class-inheritance/this-super-loop.png
deleted file mode 100644
index 637d17939..000000000
Binary files a/1-js/07-object-oriented-programming/10-class-inheritance/this-super-loop.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/this-super-loop@2x.png b/1-js/07-object-oriented-programming/10-class-inheritance/this-super-loop@2x.png
deleted file mode 100644
index af7b443bc..000000000
Binary files a/1-js/07-object-oriented-programming/10-class-inheritance/this-super-loop@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/11-instanceof/instanceof.png b/1-js/07-object-oriented-programming/11-instanceof/instanceof.png
deleted file mode 100644
index 85aa9a55f..000000000
Binary files a/1-js/07-object-oriented-programming/11-instanceof/instanceof.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/11-instanceof/instanceof@2x.png b/1-js/07-object-oriented-programming/11-instanceof/instanceof@2x.png
deleted file mode 100644
index fba771220..000000000
Binary files a/1-js/07-object-oriented-programming/11-instanceof/instanceof@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/13-mixins/mixin-inheritance.png b/1-js/07-object-oriented-programming/13-mixins/mixin-inheritance.png
deleted file mode 100644
index 7cc655036..000000000
Binary files a/1-js/07-object-oriented-programming/13-mixins/mixin-inheritance.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/13-mixins/mixin-inheritance@2x.png b/1-js/07-object-oriented-programming/13-mixins/mixin-inheritance@2x.png
deleted file mode 100644
index f53ecf68f..000000000
Binary files a/1-js/07-object-oriented-programming/13-mixins/mixin-inheritance@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/index.md b/1-js/07-object-oriented-programming/index.md
deleted file mode 100644
index 7053ada81..000000000
--- a/1-js/07-object-oriented-programming/index.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Objects, classes, inheritance
-
-In this section we return to objects and learn them even more in-depth.
diff --git a/1-js/07-object-oriented-programming/01-property-descriptors/article.md b/1-js/07-object-properties/01-property-descriptors/article.md
similarity index 94%
rename from 1-js/07-object-oriented-programming/01-property-descriptors/article.md
rename to 1-js/07-object-properties/01-property-descriptors/article.md
index 14d91800f..7768b3557 100644
--- a/1-js/07-object-oriented-programming/01-property-descriptors/article.md
+++ b/1-js/07-object-properties/01-property-descriptors/article.md
@@ -3,7 +3,9 @@
 
 As we know, objects can store properties.
 
-Till now, a property was a simple "key-value" pair to us. But an object property is actually a more complex and tunable thing.
+Till now, a property was a simple "key-value" pair to us. But an object property is actually a more flexible and powerful thing.
+
+In this chapter we'll study additional configuration options, and in the next we'll see how to invisibly turn them into getter/setter functions.
 
 ## Property flags
 
@@ -296,14 +298,13 @@ Property descriptors work at the level of individual properties.
 There are also methods that limit access to the *whole* object:
 
 [Object.preventExtensions(obj)](mdn:js/Object/preventExtensions)
-: Forbids to add properties to the object.
+: Forbids the addition of new properties to the object.
 
 [Object.seal(obj)](mdn:js/Object/seal)
-: Forbids to add/remove properties, sets for all existing properties `configurable: false`.
+: Forbids adding/removing of properties. Sets `configurable: false` for all existing properties.
 
 [Object.freeze(obj)](mdn:js/Object/freeze)
-: Forbids to add/remove/change properties, sets for all existing properties `configurable: false, writable: false`.
-
+: Forbids adding/removing/changing of properties. Sets `configurable: false, writable: false` for all existing properties.
 And also there are tests for them:
 
 [Object.isExtensible(obj)](mdn:js/Object/isExtensible)
diff --git a/1-js/07-object-oriented-programming/02-property-accessors/article.md b/1-js/07-object-properties/02-property-accessors/article.md
similarity index 94%
rename from 1-js/07-object-oriented-programming/02-property-accessors/article.md
rename to 1-js/07-object-properties/02-property-accessors/article.md
index fa4d2216d..43cd5ae6d 100644
--- a/1-js/07-object-oriented-programming/02-property-accessors/article.md
+++ b/1-js/07-object-properties/02-property-accessors/article.md
@@ -85,11 +85,12 @@ alert(user.surname); // Cooper
 Now we have a "virtual" property. It is readable and writable, but in fact does not exist.
 
 ```smart header="Accessor properties are only accessible with get/set"
-A property can either be a "data property" or an "accessor property", but not both.
+Once a property is defined with `get prop()` or `set prop()`, it's an accessor property, not a data properety any more.
 
-Once a property is defined with `get prop()` or `set prop()`, it's an accessor property. So there must be a getter to read it, and must be a setter if we want to assign it.
+- If there's a getter -- we can read `object.prop`, othrewise we can't.
+- If there's a setter -- we can set `object.prop=...`, othrewise we can't.
 
-Sometimes it's normal that there's only a setter or only a getter. But the property won't be readable or writable in that case.
+And in either case we can't `delete` an accessor property.
 ```
 
 
diff --git a/1-js/07-object-properties/index.md b/1-js/07-object-properties/index.md
new file mode 100644
index 000000000..67fcccaff
--- /dev/null
+++ b/1-js/07-object-properties/index.md
@@ -0,0 +1,3 @@
+# Object properties configuration
+
+In this section we return to objects and study their properties even more in-depth.
diff --git a/1-js/08-error-handling/1-try-catch/try-catch-flow.png b/1-js/08-error-handling/1-try-catch/try-catch-flow.png
deleted file mode 100644
index 6a91b6329..000000000
Binary files a/1-js/08-error-handling/1-try-catch/try-catch-flow.png and /dev/null differ
diff --git a/1-js/08-error-handling/1-try-catch/try-catch-flow@2x.png b/1-js/08-error-handling/1-try-catch/try-catch-flow@2x.png
deleted file mode 100644
index 8bf9680fd..000000000
Binary files a/1-js/08-error-handling/1-try-catch/try-catch-flow@2x.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/1-property-after-delete/solution.md b/1-js/08-prototypes/01-prototype-inheritance/1-property-after-delete/solution.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/03-prototype-inheritance/1-property-after-delete/solution.md
rename to 1-js/08-prototypes/01-prototype-inheritance/1-property-after-delete/solution.md
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/1-property-after-delete/task.md b/1-js/08-prototypes/01-prototype-inheritance/1-property-after-delete/task.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/03-prototype-inheritance/1-property-after-delete/task.md
rename to 1-js/08-prototypes/01-prototype-inheritance/1-property-after-delete/task.md
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/2-search-algorithm/solution.md b/1-js/08-prototypes/01-prototype-inheritance/2-search-algorithm/solution.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/03-prototype-inheritance/2-search-algorithm/solution.md
rename to 1-js/08-prototypes/01-prototype-inheritance/2-search-algorithm/solution.md
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/2-search-algorithm/task.md b/1-js/08-prototypes/01-prototype-inheritance/2-search-algorithm/task.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/03-prototype-inheritance/2-search-algorithm/task.md
rename to 1-js/08-prototypes/01-prototype-inheritance/2-search-algorithm/task.md
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/3-proto-and-this/solution.md b/1-js/08-prototypes/01-prototype-inheritance/3-proto-and-this/solution.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/03-prototype-inheritance/3-proto-and-this/solution.md
rename to 1-js/08-prototypes/01-prototype-inheritance/3-proto-and-this/solution.md
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/3-proto-and-this/task.md b/1-js/08-prototypes/01-prototype-inheritance/3-proto-and-this/task.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/03-prototype-inheritance/3-proto-and-this/task.md
rename to 1-js/08-prototypes/01-prototype-inheritance/3-proto-and-this/task.md
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/4-hamster-proto/solution.md b/1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/solution.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/03-prototype-inheritance/4-hamster-proto/solution.md
rename to 1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/solution.md
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/4-hamster-proto/task.md b/1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/task.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/03-prototype-inheritance/4-hamster-proto/task.md
rename to 1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/task.md
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/article.md b/1-js/08-prototypes/01-prototype-inheritance/article.md
similarity index 80%
rename from 1-js/07-object-oriented-programming/03-prototype-inheritance/article.md
rename to 1-js/08-prototypes/01-prototype-inheritance/article.md
index fa61cbc89..1641de236 100644
--- a/1-js/07-object-oriented-programming/03-prototype-inheritance/article.md
+++ b/1-js/08-prototypes/01-prototype-inheritance/article.md
@@ -31,7 +31,13 @@ rabbit.__proto__ = animal;
 */!*
 ```
 
-Please note that `__proto__` is *not the same* as `[[Prototype]]`. That's a getter/setter for it. We'll talk about other ways of setting it later, but for now `__proto__` will do just fine.
+```smart header="`__proto__` is a historical getter/setter for `[[Prototype]]`"
+Please note that `__proto__` is *not the same* as `[[Prototype]]`. That's a getter/setter for it.
+
+It exists for historical reasons, in modern language it is replaced with functions `Object.getPrototypeOf/Object.setPrototypeOf` that also get/set the prototype. We'll study the reasons for that and these functions later.
+
+By the specification, `__proto__` must only be supported by browsers, but in fact all environments including server-side support it. For now, as `__proto__` notation is a little bit more intuitively obvious, we'll use it in the examples.
+```
 
 If we look for a property in `rabbit`, and it's missing, JavaScript automatically takes it from `animal`.
 
@@ -62,7 +68,7 @@ Then, when `alert` tries to read property `rabbit.eats` `(**)`, it's not in `rab
 
 ![](proto-animal-rabbit.png)
 
-Here we can say that "`animal` is the prototype of `rabbit`" or "`rabbit` prototypally inherits from `animal`".
+Here we can say that "`animal` is the prototype of `rabbit`" or "`rabbit` prototypically inherits from `animal`".
 
 So if `animal` has a lot of useful properties and methods, then they become automatically available in `rabbit`. Such properties are called "inherited".
 
@@ -106,13 +112,17 @@ let animal = {
 
 let rabbit = {
   jumps: true,
+*!*
   __proto__: animal
+*/!*
 };
 
 let longEar = {
   earLength: 10,
+*!*
   __proto__: rabbit
-}
+*/!*
+};
 
 // walk is taken from the prototype chain
 longEar.walk(); // Animal walk
@@ -124,15 +134,15 @@ alert(longEar.jumps); // true (from rabbit)
 There are actually only two limitations:
 
 1. The references can't go in circles. JavaScript will throw an error if we try to assign `__proto__` in a circle.
-2. The value of `__proto__` can be either an object or `null`. All other values (like primitives) are ignored.
+2. The value of `__proto__` can be either an object or `null`, other types (like primitives) are ignored.
 
 Also it may be obvious, but still: there can be only one `[[Prototype]]`. An object may not inherit from two others.
 
-## Read/write rules
+## Writing doesn't use prototype
 
 The prototype is only used for reading properties.
 
-For data properties (not getters/setters) write/delete operations work directly with the object.
+Write/delete operations work directly with the object.
 
 In the example below, we assign its own `walk` method to `rabbit`:
 
@@ -146,7 +156,7 @@ let animal = {
 
 let rabbit = {
   __proto__: animal
-}
+};
 
 *!*
 rabbit.walk = function() {
@@ -161,9 +171,9 @@ From now on, `rabbit.walk()` call finds the method immediately in the object and
 
 ![](proto-animal-rabbit-walk-2.png)
 
-For getters/setters -- if we read/write a property, they are looked up in the prototype and invoked.
+That's for data properties only, not for accessors. If a property is a getter/setter, then it behaves like a function: getters/setters are looked up in the prototype.
 
-For instance, check out `admin.fullName` property in the code below:
+For that reason `admin.fullName` works correctly in the code below:
 
 ```js run
 let user = {
@@ -194,15 +204,15 @@ Here in the line `(*)` the property `admin.fullName` has a getter in the prototy
 
 ## The value of "this"
 
-An interesting question may arise in the example above: what's the value of `this` inside `set fullName(value)`? Where the properties `this.name` and `this.surname` are written: `user` or `admin`?
+An interesting question may arise in the example above: what's the value of `this` inside `set fullName(value)`? Where the properties `this.name` and `this.surname` are written: into `user` or `admin`?
 
 The answer is simple: `this` is not affected by prototypes at all.
 
 **No matter where the method is found: in an object or its prototype. In a method call, `this` is always the object before the dot.**
 
-So, the setter actually uses `admin` as `this`, not `user`.
+So, the setter call `admin.fullName=` uses `admin` as `this`, not `user`.
 
-That is actually a super-important thing, because we may have a big object with many methods and inherit from it. Then we can run its methods on inherited objects and they will modify the state of these objects, not the big one.
+That is actually a super-important thing, because we may have a big object with many methods and inherit from it. Then inherited objects can run its methods, and they will modify the state of these objects, not the big one.
 
 For instance, here `animal` represents a "method storage", and `rabbit` makes use of it.
 
@@ -244,7 +254,7 @@ As a result, methods are shared, but the object state is not.
 ## Summary
 
 - In JavaScript, all objects have a hidden `[[Prototype]]` property that's either another object or `null`.
-- We can use `obj.__proto__` to access it (there are other ways too, to be covered soon).
+- We can use `obj.__proto__` to access it (a historical getter/setter, there are other ways, to be covered soon).
 - The object referenced by `[[Prototype]]` is called a "prototype".
 - If we want to read a property of `obj` or call a method, and it doesn't exist, then JavaScript tries to find it in the prototype. Write/delete operations work directly on the object, they don't use the prototype (unless the property is actually a setter).
 - If we call `obj.method()`, and the `method` is taken from the prototype, `this` still references `obj`. So methods always work with the current object even if they are inherited.
diff --git a/1-js/08-prototypes/01-prototype-inheritance/object-prototype-empty.png b/1-js/08-prototypes/01-prototype-inheritance/object-prototype-empty.png
new file mode 100644
index 000000000..3ecff3fdd
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/object-prototype-empty.png differ
diff --git a/1-js/08-prototypes/01-prototype-inheritance/object-prototype-empty@2x.png b/1-js/08-prototypes/01-prototype-inheritance/object-prototype-empty@2x.png
new file mode 100644
index 000000000..f80e61e68
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/object-prototype-empty@2x.png differ
diff --git a/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-chain.png b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-chain.png
new file mode 100644
index 000000000..48e02ad18
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-chain.png differ
diff --git a/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-chain@2x.png b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-chain@2x.png
new file mode 100644
index 000000000..1a04db885
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-chain@2x.png differ
diff --git a/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk-2.png b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk-2.png
new file mode 100644
index 000000000..22b867fc8
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk-2.png differ
diff --git a/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk-2@2x.png b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk-2@2x.png
new file mode 100644
index 000000000..8d9f9f1ae
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk-2@2x.png differ
diff --git a/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk-3.png b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk-3.png
new file mode 100644
index 000000000..bc76d64ba
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk-3.png differ
diff --git a/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk-3@2x.png b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk-3@2x.png
new file mode 100644
index 000000000..725a4c150
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk-3@2x.png differ
diff --git a/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk.png b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk.png
new file mode 100644
index 000000000..29fc6d503
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk.png differ
diff --git a/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk@2x.png b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk@2x.png
new file mode 100644
index 000000000..724d6111b
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit-walk@2x.png differ
diff --git a/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit.png b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit.png
new file mode 100644
index 000000000..d50327f0e
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit.png differ
diff --git a/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit@2x.png b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit@2x.png
new file mode 100644
index 000000000..0506b92b6
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/proto-animal-rabbit@2x.png differ
diff --git a/1-js/08-prototypes/01-prototype-inheritance/proto-user-admin.png b/1-js/08-prototypes/01-prototype-inheritance/proto-user-admin.png
new file mode 100644
index 000000000..c37d00780
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/proto-user-admin.png differ
diff --git a/1-js/08-prototypes/01-prototype-inheritance/proto-user-admin@2x.png b/1-js/08-prototypes/01-prototype-inheritance/proto-user-admin@2x.png
new file mode 100644
index 000000000..8c3f546eb
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/proto-user-admin@2x.png differ
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/1-changing-prototype/solution.md b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/04-function-prototype/1-changing-prototype/solution.md
rename to 1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/1-changing-prototype/task.md b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/04-function-prototype/1-changing-prototype/task.md
rename to 1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/4-new-object-same-constructor/solution.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/04-function-prototype/4-new-object-same-constructor/solution.md
rename to 1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/4-new-object-same-constructor/task.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/04-function-prototype/4-new-object-same-constructor/task.md
rename to 1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/article.md b/1-js/08-prototypes/02-function-prototype/article.md
similarity index 76%
rename from 1-js/07-object-oriented-programming/04-function-prototype/article.md
rename to 1-js/08-prototypes/02-function-prototype/article.md
index d4b453850..669a9a658 100644
--- a/1-js/07-object-oriented-programming/04-function-prototype/article.md
+++ b/1-js/08-prototypes/02-function-prototype/article.md
@@ -1,18 +1,14 @@
 # F.prototype
 
-In modern JavaScript we can set a prototype using `__proto__`, as described in the previous article. But it wasn't like that all the time.
+Remember, new objects can be created with a constructor function, like `new F()`.
 
-JavaScript has had prototypal inheritance from the beginning. It was one of the core features of the language.
+If `F.prototype` is an object, then `new` operator uses it to set `[[Prototype]]` for the new object.
 
-But in the old times, there was another (and the only) way to set it: to use a `"prototype"` property of the constructor function. And there are still many scripts that use it.
+```smart
+JavaScript had prototypal inheritance from the beginning. It was one of the core features of the language.
 
-## The "prototype" property
-
-As we know already, `new F()` creates a new object.
-
-When a new object is created with `new F()`, the object's `[[Prototype]]` is set to `F.prototype`.
-
-In other words, if `F` has a `prototype` property with a value of the object type, then `new` operator uses it to set `[[Prototype]]` for the new object.
+But in the old times, there was no direct access to it. The only thing that worked reliably was a `"prototype"` property of the constructor function, described in this chapter. So there are many scripts that still use it.
+```
 
 Please note that `F.prototype` here means a regular property named `"prototype"` on `F`. It sounds something similar to the term "prototype", but here we really mean a regular property with this name.
 
@@ -42,8 +38,13 @@ That's the resulting picture:
 
 ![](proto-constructor-animal-rabbit.png)
 
-On the picture, `"prototype"` is a horizontal arrow, it's a regular property, and `[[Prototype]]` is vertical, meaning the inheritance of `rabbit` from `animal`.
+On the picture, `"prototype"` is a horizontal arrow, meaning a regular property, and `[[Prototype]]` is vertical, meaning the inheritance of `rabbit` from `animal`.
+
+```smart header="`F.prototype` only used at `new F` time"
+`F.prototype` property is only used when `new F` is called, it assigns `[[Prototype]]` of the new object. After that, there's no connection between `F.prototype` and the new object. Think of it as a "one-time gift".
 
+If, after the creation, `F.prototype` property changes (`F.property = <another object>`), then new objects created by `new F` will have another object as `[[Prototype]]`, but already existing objects keep the old one.
+```
 
 ## Default F.prototype, constructor property
 
@@ -139,7 +140,7 @@ Rabbit.prototype.jumps = true
 // the default Rabbit.prototype.constructor is preserved
 ```
 
-Or, alternatively, recreate the `constructor` property it manually:
+Or, alternatively, recreate the `constructor` property manually:
 
 ```js
 Rabbit.prototype = {
diff --git a/1-js/08-prototypes/02-function-prototype/function-prototype-constructor.png b/1-js/08-prototypes/02-function-prototype/function-prototype-constructor.png
new file mode 100644
index 000000000..6ab9c6934
Binary files /dev/null and b/1-js/08-prototypes/02-function-prototype/function-prototype-constructor.png differ
diff --git a/1-js/08-prototypes/02-function-prototype/function-prototype-constructor@2x.png b/1-js/08-prototypes/02-function-prototype/function-prototype-constructor@2x.png
new file mode 100644
index 000000000..3beb0a573
Binary files /dev/null and b/1-js/08-prototypes/02-function-prototype/function-prototype-constructor@2x.png differ
diff --git a/1-js/08-prototypes/02-function-prototype/native-prototypes-array-tostring.png b/1-js/08-prototypes/02-function-prototype/native-prototypes-array-tostring.png
new file mode 100644
index 000000000..c47938674
Binary files /dev/null and b/1-js/08-prototypes/02-function-prototype/native-prototypes-array-tostring.png differ
diff --git a/1-js/08-prototypes/02-function-prototype/native-prototypes-array-tostring@2x.png b/1-js/08-prototypes/02-function-prototype/native-prototypes-array-tostring@2x.png
new file mode 100644
index 000000000..293c88bf9
Binary files /dev/null and b/1-js/08-prototypes/02-function-prototype/native-prototypes-array-tostring@2x.png differ
diff --git a/1-js/08-prototypes/02-function-prototype/native-prototypes-classes.png b/1-js/08-prototypes/02-function-prototype/native-prototypes-classes.png
new file mode 100644
index 000000000..c4658a929
Binary files /dev/null and b/1-js/08-prototypes/02-function-prototype/native-prototypes-classes.png differ
diff --git a/1-js/08-prototypes/02-function-prototype/native-prototypes-classes@2x.png b/1-js/08-prototypes/02-function-prototype/native-prototypes-classes@2x.png
new file mode 100644
index 000000000..79445fac9
Binary files /dev/null and b/1-js/08-prototypes/02-function-prototype/native-prototypes-classes@2x.png differ
diff --git a/1-js/08-prototypes/02-function-prototype/object-prototype-1.png b/1-js/08-prototypes/02-function-prototype/object-prototype-1.png
new file mode 100644
index 000000000..a69cad4a1
Binary files /dev/null and b/1-js/08-prototypes/02-function-prototype/object-prototype-1.png differ
diff --git a/1-js/08-prototypes/02-function-prototype/object-prototype-1@2x.png b/1-js/08-prototypes/02-function-prototype/object-prototype-1@2x.png
new file mode 100644
index 000000000..9d661ac17
Binary files /dev/null and b/1-js/08-prototypes/02-function-prototype/object-prototype-1@2x.png differ
diff --git a/1-js/08-prototypes/02-function-prototype/object-prototype.png b/1-js/08-prototypes/02-function-prototype/object-prototype.png
new file mode 100644
index 000000000..820ffcc73
Binary files /dev/null and b/1-js/08-prototypes/02-function-prototype/object-prototype.png differ
diff --git a/1-js/08-prototypes/02-function-prototype/object-prototype@2x.png b/1-js/08-prototypes/02-function-prototype/object-prototype@2x.png
new file mode 100644
index 000000000..1eb7e8749
Binary files /dev/null and b/1-js/08-prototypes/02-function-prototype/object-prototype@2x.png differ
diff --git a/1-js/08-prototypes/02-function-prototype/proto-constructor-animal-rabbit.png b/1-js/08-prototypes/02-function-prototype/proto-constructor-animal-rabbit.png
new file mode 100644
index 000000000..4b381460a
Binary files /dev/null and b/1-js/08-prototypes/02-function-prototype/proto-constructor-animal-rabbit.png differ
diff --git a/1-js/08-prototypes/02-function-prototype/proto-constructor-animal-rabbit@2x.png b/1-js/08-prototypes/02-function-prototype/proto-constructor-animal-rabbit@2x.png
new file mode 100644
index 000000000..c6e6ab5f6
Binary files /dev/null and b/1-js/08-prototypes/02-function-prototype/proto-constructor-animal-rabbit@2x.png differ
diff --git a/1-js/08-prototypes/02-function-prototype/rabbit-animal-object.png b/1-js/08-prototypes/02-function-prototype/rabbit-animal-object.png
new file mode 100644
index 000000000..3924233dd
Binary files /dev/null and b/1-js/08-prototypes/02-function-prototype/rabbit-animal-object.png differ
diff --git a/1-js/08-prototypes/02-function-prototype/rabbit-animal-object@2x.png b/1-js/08-prototypes/02-function-prototype/rabbit-animal-object@2x.png
new file mode 100644
index 000000000..5350a1935
Binary files /dev/null and b/1-js/08-prototypes/02-function-prototype/rabbit-animal-object@2x.png differ
diff --git a/1-js/08-prototypes/02-function-prototype/rabbit-prototype-constructor.png b/1-js/08-prototypes/02-function-prototype/rabbit-prototype-constructor.png
new file mode 100644
index 000000000..8f3519a74
Binary files /dev/null and b/1-js/08-prototypes/02-function-prototype/rabbit-prototype-constructor.png differ
diff --git a/1-js/08-prototypes/02-function-prototype/rabbit-prototype-constructor@2x.png b/1-js/08-prototypes/02-function-prototype/rabbit-prototype-constructor@2x.png
new file mode 100644
index 000000000..07acb8f4a
Binary files /dev/null and b/1-js/08-prototypes/02-function-prototype/rabbit-prototype-constructor@2x.png differ
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/1-defer-to-prototype/solution.md b/1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/solution.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/05-native-prototypes/1-defer-to-prototype/solution.md
rename to 1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/solution.md
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/1-defer-to-prototype/task.md b/1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/task.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/05-native-prototypes/1-defer-to-prototype/task.md
rename to 1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/task.md
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/2-defer-to-prototype-extended/solution.md b/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/05-native-prototypes/2-defer-to-prototype-extended/solution.md
rename to 1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/2-defer-to-prototype-extended/task.md b/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/task.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/05-native-prototypes/2-defer-to-prototype-extended/task.md
rename to 1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/task.md
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
similarity index 61%
rename from 1-js/07-object-oriented-programming/05-native-prototypes/article.md
rename to 1-js/08-prototypes/03-native-prototypes/article.md
index 4777f356f..d540be5f2 100644
--- a/1-js/07-object-oriented-programming/05-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -15,17 +15,17 @@ alert( obj ); // "[object Object]" ?
 
 Where's the code that generates the string `"[object Object]"`? That's a built-in `toString` method, but where is it? The `obj` is empty!
 
-...But the short notation `obj = {}` is the same as `obj = new Object()`, where `Object` -- is a built-in object constructor function. And that function has `Object.prototype` that references a huge object with `toString` and other functions.
+...But the short notation `obj = {}` is the same as `obj = new Object()`, where `Object` is a built-in object constructor function, with its own `prototype` referencing a huge object with `toString` and other methods.
 
-Like this (all that is built-in):
+Here's what's going on:
 
 ![](object-prototype.png)
 
-When `new Object()` is called (or a literal object `{...}` is created), the `[[Prototype]]` of it is set to `Object.prototype` by the rule that we've discussed in the previous chapter:
+When `new Object()` is called (or a literal object `{...}` is created), the `[[Prototype]]` of it is set to `Object.prototype` according to the rule that we discussed in the previous chapter:
 
 ![](object-prototype-1.png)
 
-Afterwards when `obj.toString()` is called -- the method is taken from `Object.prototype`.
+So then when `obj.toString()` is called the method is taken from `Object.prototype`.
 
 We can check it like this:
 
@@ -48,7 +48,7 @@ Other built-in objects such as `Array`, `Date`, `Function` and others also keep
 
 For instance, when we create an array `[1, 2, 3]`, the default `new Array()` constructor is  used internally. So the array data is written into the new object, and `Array.prototype` becomes its prototype and provides methods. That's very memory-efficient.
 
-By specification, all built-in prototypes have `Object.prototype` on the top. Sometimes people say that "everything inherits from objects".
+By specification, all of the built-in prototypes have `Object.prototype` on the top. Sometimes people say that "everything inherits from objects".
 
 Here's the overall picture (for 3 built-ins to fit):
 
@@ -82,11 +82,11 @@ As we've seen before, `Object.prototype` has `toString` as well, but `Array.prot
 ![](native-prototypes-array-tostring.png)
 
 
-In-browser tools like Chrome developer console also show inheritance (may need to use `console.dir` for built-in objects):
+In-browser tools like Chrome developer console also show inheritance (`console.dir` may need to be used for built-in objects):
 
 ![](console_dir_array.png)
 
-Other built-in objects also work the same way. Even functions. They are objects of a built-in `Function` constructor, and their methods: `call/apply` and others are taken from `Function.prototype`. Functions have their own `toString` too.
+Other built-in objects also work the same way. Even functions -- they are objects of a built-in `Function` constructor, and their methods (`call`/`apply` and others) are taken from `Function.prototype`. Functions have their own `toString` too.
 
 ```js run
 function f() {}
@@ -119,11 +119,19 @@ String.prototype.show = function() {
 "BOOM!".show(); // BOOM!
 ```
 
-During the process of development we may have ideas which new built-in methods we'd like to have. And there may be a slight temptation to add them to native prototypes. But that is generally a bad idea.
+During the process of development, we may have ideas for new built-in methods we'd like to have, and we may be tempted to add them to native prototypes. But that is generally a bad idea.
 
-Prototypes are global, so it's easy to get a conflict. If two libraries add a method `String.prototype.show`, then one of them overwrites the other one.
+```warn
+Prototypes are global, so it's easy to get a conflict. If two libraries add a method `String.prototype.show`, then one of them will be overwriting the other.
 
-In modern programming, there is only one case when modifying native prototypes is approved. That's polyfills. In other words, if there's a method in JavaScript specification that is not yet supported by our JavaScript engine (or any of those that we want to support), then may implement it manually and populate the built-in prototype with it.
+So, generally, modifying a native prototype is considered a bad idea.
+```
+
+**In modern programming, there is only one case where modifying native prototypes is approved. That's polyfilling.**
+
+Polyfilling is a term for making a substitute for a method that exists in JavaScript specification, but not yet supported by current JavaScript engine.
+
+Then we may implement it manually and populate the built-in prototype with it.
 
 For instance:
 
@@ -134,9 +142,9 @@ if (!String.prototype.repeat) { // if there's no such method
   String.prototype.repeat = function(n) {
     // repeat the string n times
 
-    // actually, the code should be more complex than that,
-    // throw errors for negative values of "n"
-    // the full algorithm is in the specification
+    // actually, the code should be a little bit more complex than that
+    // (the full algorithm is in the specification)
+    // but even an imperfect polyfill is often considered good enough
     return new Array(n + 1).join(this);
   };
 }
@@ -144,37 +152,45 @@ if (!String.prototype.repeat) { // if there's no such method
 alert( "La".repeat(3) ); // LaLaLa
 ```
 
+
 ## Borrowing from prototypes
 
-In the chapter <info:call-apply-decorators#method-borrowing> we talked about method borrowing:
+In the chapter <info:call-apply-decorators#method-borrowing> we talked about method borrowing.
+
+That's when we take a method from one object and copy it into another.
+
+Some methods of native prototypes are often borrowed.
+
+For instance, if we're making an array-like object, we may want to copy some array methods to it.
+
+E.g.
 
 ```js run
-function showArgs() {
+let obj = {
+  0: "Hello",
+  1: "world!",
+  length: 2,
+};
+
 *!*
-  // borrow join from array and call in the context of arguments
-  alert( [].join.call(arguments, " - ") );
+obj.join = Array.prototype.join;
 */!*
-}
 
-showArgs("John", "Pete", "Alice"); // John - Pete - Alice
+alert( obj.join(',') ); // Hello,world!
 ```
 
-Because `join` resides in `Array.prototype`, we can call it from there directly and rewrite it as:
+It works, because the internal algorithm of the built-in `join` method only cares about the correct indexes and the `length` property, it doesn't check that the object is indeed the array. And many built-in methods are like that.
 
-```js
-function showArgs() {
-*!*
-  alert( Array.prototype.join.call(arguments, " - ") );
-*/!*
-}
-```
+Another possibility is to inherit by setting `obj.__proto__` to `Array.prototype`, so all `Array` methods are automatically available in `obj`.
+
+But that's impossible if `obj` already inherits from another object. Remember, we only can inherit from one object at a time.
 
-That's more efficient, because it avoids the creation of an extra array object `[]`. On the other hand, it is longer to write.
+Borrowing methods is flexible, it allows to mix functionality from different objects if needed.
 
 ## Summary
 
 - All built-in objects follow the same pattern:
     - The methods are stored in the prototype (`Array.prototype`, `Object.prototype`, `Date.prototype` etc).
     - The object itself stores only the data (array items, object properties, the date).
-- Primitives also store methods in prototypes of wrapper objects: `Number.prototype`, `String.prototype`, `Boolean.prototype`. There are no wrapper objects only for `undefined` and `null`.
+- Primitives also store methods in prototypes of wrapper objects: `Number.prototype`, `String.prototype`, `Boolean.prototype`. Only `undefined` and `null` do not have wrapper objects.
 - Built-in prototypes can be modified or populated with new methods. But it's not recommended to change them. Probably the only allowable cause is when we add-in a new standard, but not yet supported by the engine JavaScript method.
diff --git a/1-js/07-object-oriented-programming/05-native-prototypes/console_dir_array.png b/1-js/08-prototypes/03-native-prototypes/console_dir_array.png
similarity index 100%
rename from 1-js/07-object-oriented-programming/05-native-prototypes/console_dir_array.png
rename to 1-js/08-prototypes/03-native-prototypes/console_dir_array.png
diff --git a/1-js/08-prototypes/03-native-prototypes/function-prototype-constructor.png b/1-js/08-prototypes/03-native-prototypes/function-prototype-constructor.png
new file mode 100644
index 000000000..6ab9c6934
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/function-prototype-constructor.png differ
diff --git a/1-js/08-prototypes/03-native-prototypes/function-prototype-constructor@2x.png b/1-js/08-prototypes/03-native-prototypes/function-prototype-constructor@2x.png
new file mode 100644
index 000000000..3beb0a573
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/function-prototype-constructor@2x.png differ
diff --git a/1-js/08-prototypes/03-native-prototypes/native-prototypes-array-tostring.png b/1-js/08-prototypes/03-native-prototypes/native-prototypes-array-tostring.png
new file mode 100644
index 000000000..c47938674
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/native-prototypes-array-tostring.png differ
diff --git a/1-js/08-prototypes/03-native-prototypes/native-prototypes-array-tostring@2x.png b/1-js/08-prototypes/03-native-prototypes/native-prototypes-array-tostring@2x.png
new file mode 100644
index 000000000..293c88bf9
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/native-prototypes-array-tostring@2x.png differ
diff --git a/1-js/08-prototypes/03-native-prototypes/native-prototypes-classes.png b/1-js/08-prototypes/03-native-prototypes/native-prototypes-classes.png
new file mode 100644
index 000000000..c4658a929
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/native-prototypes-classes.png differ
diff --git a/1-js/08-prototypes/03-native-prototypes/native-prototypes-classes@2x.png b/1-js/08-prototypes/03-native-prototypes/native-prototypes-classes@2x.png
new file mode 100644
index 000000000..79445fac9
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/native-prototypes-classes@2x.png differ
diff --git a/1-js/08-prototypes/03-native-prototypes/object-prototype-1.png b/1-js/08-prototypes/03-native-prototypes/object-prototype-1.png
new file mode 100644
index 000000000..a69cad4a1
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/object-prototype-1.png differ
diff --git a/1-js/08-prototypes/03-native-prototypes/object-prototype-1@2x.png b/1-js/08-prototypes/03-native-prototypes/object-prototype-1@2x.png
new file mode 100644
index 000000000..9d661ac17
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/object-prototype-1@2x.png differ
diff --git a/1-js/08-prototypes/03-native-prototypes/object-prototype-null.png b/1-js/08-prototypes/03-native-prototypes/object-prototype-null.png
new file mode 100644
index 000000000..792c4f423
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/object-prototype-null.png differ
diff --git a/1-js/08-prototypes/03-native-prototypes/object-prototype-null@2x.png b/1-js/08-prototypes/03-native-prototypes/object-prototype-null@2x.png
new file mode 100644
index 000000000..d97efa884
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/object-prototype-null@2x.png differ
diff --git a/1-js/08-prototypes/03-native-prototypes/object-prototype.png b/1-js/08-prototypes/03-native-prototypes/object-prototype.png
new file mode 100644
index 000000000..820ffcc73
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/object-prototype.png differ
diff --git a/1-js/08-prototypes/03-native-prototypes/object-prototype@2x.png b/1-js/08-prototypes/03-native-prototypes/object-prototype@2x.png
new file mode 100644
index 000000000..1eb7e8749
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/object-prototype@2x.png differ
diff --git a/1-js/08-prototypes/03-native-prototypes/proto-constructor-animal-rabbit.png b/1-js/08-prototypes/03-native-prototypes/proto-constructor-animal-rabbit.png
new file mode 100644
index 000000000..4b381460a
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/proto-constructor-animal-rabbit.png differ
diff --git a/1-js/08-prototypes/03-native-prototypes/proto-constructor-animal-rabbit@2x.png b/1-js/08-prototypes/03-native-prototypes/proto-constructor-animal-rabbit@2x.png
new file mode 100644
index 000000000..c6e6ab5f6
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/proto-constructor-animal-rabbit@2x.png differ
diff --git a/1-js/08-prototypes/03-native-prototypes/rabbit-prototype-constructor.png b/1-js/08-prototypes/03-native-prototypes/rabbit-prototype-constructor.png
new file mode 100644
index 000000000..8f3519a74
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/rabbit-prototype-constructor.png differ
diff --git a/1-js/08-prototypes/03-native-prototypes/rabbit-prototype-constructor@2x.png b/1-js/08-prototypes/03-native-prototypes/rabbit-prototype-constructor@2x.png
new file mode 100644
index 000000000..07acb8f4a
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/rabbit-prototype-constructor@2x.png differ
diff --git a/1-js/07-object-oriented-programming/06-prototype-methods/2-dictionary-tostring/solution.md b/1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/solution.md
similarity index 79%
rename from 1-js/07-object-oriented-programming/06-prototype-methods/2-dictionary-tostring/solution.md
rename to 1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/solution.md
index debaecd6a..a92e17900 100644
--- a/1-js/07-object-oriented-programming/06-prototype-methods/2-dictionary-tostring/solution.md
+++ b/1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/solution.md
@@ -1,7 +1,7 @@
 
 The method can take all enumerable keys using `Object.keys` and output their list.
 
-To make `toString` non-enumerable, let's define it using a property descriptor. The syntax of `Object.create` allows to provide an object with property descriptors as the second argument.
+To make `toString` non-enumerable, let's define it using a property descriptor. The syntax of `Object.create` allows us to provide an object with property descriptors as the second argument.
 
 ```js run
 *!*
@@ -27,3 +27,5 @@ alert(dictionary); // "apple,__proto__"
 ```
 
 When we create a property using a descriptor, its flags are `false` by default. So in the code above, `dictionary.toString` is non-enumerable.
+
+See the the chapter [](info:property-descriptors) for review.
diff --git a/1-js/07-object-oriented-programming/06-prototype-methods/2-dictionary-tostring/task.md b/1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/task.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/06-prototype-methods/2-dictionary-tostring/task.md
rename to 1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/task.md
diff --git a/1-js/07-object-oriented-programming/06-prototype-methods/3-compare-calls/solution.md b/1-js/08-prototypes/04-prototype-methods/3-compare-calls/solution.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/06-prototype-methods/3-compare-calls/solution.md
rename to 1-js/08-prototypes/04-prototype-methods/3-compare-calls/solution.md
diff --git a/1-js/07-object-oriented-programming/06-prototype-methods/3-compare-calls/task.md b/1-js/08-prototypes/04-prototype-methods/3-compare-calls/task.md
similarity index 92%
rename from 1-js/07-object-oriented-programming/06-prototype-methods/3-compare-calls/task.md
rename to 1-js/08-prototypes/04-prototype-methods/3-compare-calls/task.md
index 92653bd8c..09bb7f1ed 100644
--- a/1-js/07-object-oriented-programming/06-prototype-methods/3-compare-calls/task.md
+++ b/1-js/08-prototypes/04-prototype-methods/3-compare-calls/task.md
@@ -2,7 +2,7 @@ importance: 5
 
 ---
 
-# The difference beteeen calls
+# The difference between calls
 
 Let's create a new `rabbit` object:
 
diff --git a/1-js/07-object-oriented-programming/06-prototype-methods/article.md b/1-js/08-prototypes/04-prototype-methods/article.md
similarity index 63%
rename from 1-js/07-object-oriented-programming/06-prototype-methods/article.md
rename to 1-js/08-prototypes/04-prototype-methods/article.md
index e253e8af7..5a9838d1c 100644
--- a/1-js/07-object-oriented-programming/06-prototype-methods/article.md
+++ b/1-js/08-prototypes/04-prototype-methods/article.md
@@ -1,14 +1,18 @@
 
-# Methods for prototypes
+# Prototype methods, objects without __proto__
 
-In this chapter we cover additional methods to work with a prototype.
+In the first chapter of this section, we mentioned that there are modern methods to setup a prototype.
 
-There are also other ways to get/set a prototype, besides those that we already know:
+The `__proto__` is considered outdated and somewhat deprecated (in browser-only part of the JavaScript standard).
+
+The modern methods are:
 
 - [Object.create(proto[, descriptors])](mdn:js/Object/create) -- creates an empty object with given `proto` as `[[Prototype]]` and optional property descriptors.
 - [Object.getPrototypeOf(obj)](mdn:js/Object/getPrototypeOf) -- returns the `[[Prototype]]` of `obj`.
 - [Object.setPrototypeOf(obj, proto)](mdn:js/Object/setPrototypeOf) -- sets the `[[Prototype]]` of `obj` to `proto`.
 
+These should be used instead of `__proto__`.
+
 For instance:
 
 ```js run
@@ -72,7 +76,13 @@ That's for historical reasons.
 
 As of now we have all these ways at our disposal.
 
-Technically, we can get/set `[[Prototype]]` at any time. But usually we only set it once at the object creation time, and then do not modify: `rabbit` inherits from `animal`, and that is not going to change. And JavaScript engines are highly optimized to that. Changing a prototype "on-the-fly" with `Object.setPrototypeOf` or `obj.__proto__=` is a very slow operation. But it is possible.
+Why was `__proto__` replaced by the functions? That's an interesting question, requiring us to understand why `__proto__` is bad. Read on to get the answer.
+
+```warn header="Don't reset `[[Prototype]]` unless the speed doesn't matter"
+Technically, we can get/set `[[Prototype]]` at any time. But usually we only set it once at the object creation time, and then do not modify: `rabbit` inherits from `animal`, and that is not going to change.
+
+And JavaScript engines are highly optimized to that. Changing a prototype "on-the-fly" with `Object.setPrototypeOf` or `obj.__proto__=` is a very slow operation, it breaks internal optimizations for object property access operations. So evade it unless you know what you're doing, or JavaScript speed totally doesn't matter for you.
+```
 
 ## "Very plain" objects
 
@@ -95,11 +105,13 @@ Here if the user types in `__proto__`, the assignment is ignored!
 
 That shouldn't surprise us. The `__proto__` property is special: it must be either an object or `null`, a string can not become a prototype.
 
-But we did not intend to implement such behavior, right? We want to store key/value pairs, and the key named `"__proto__"` was not properly saved. So that's a bug. Here the consequences are not terrible. But in other cases the prototype may indeed be changed, so the execution may go wrong in totally unexpected ways.
+But we didn't *intend* to implement such behavior, right? We want to store key/value pairs, and the key named `"__proto__"` was not properly saved. So that's a bug!
+
+Here the consequences are not terrible. But in other cases the prototype may indeed be changed, so the execution may go wrong in totally unexpected ways.
 
 What's worst -- usually developers do not think about such possibility at all. That makes such bugs hard to notice and even turn them into vulnerabilities, especially when JavaScript is used on server-side.
 
-Such thing happens only with `__proto__`. All other properties are "assignable" normally.
+Unexpected things also may happen when accessing `toString` property -- that's a function by default, and other built-in properties.
 
 How to evade the problem?
 
@@ -111,9 +123,9 @@ The `__proto__` is not a property of an object, but an accessor property of `Obj
 
 ![](object-prototype-2.png)
 
-So, if `obj.__proto__` is read or assigned, the corresponding getter/setter is called from its prototype, and it gets/sets `[[Prototype]]`.
+So, if `obj.__proto__` is read or set, the corresponding getter/setter is called from its prototype, and it gets/sets `[[Prototype]]`.
 
-As it was said in the beginning: `__proto__` is a way to access `[[Prototype]]`, it is not `[[Prototype]]` itself.
+As it was said in the beginning of this tutorial section: `__proto__` is a way to access `[[Prototype]]`, it is not `[[Prototype]]` itself.
 
 Now, if we want to use an object as an associative array, we can do it with a little trick:
 
@@ -153,93 +165,31 @@ Please note that most object-related methods are `Object.something(...)`, like `
 
 ```js run
 let chineseDictionary = Object.create(null);
-chineseDictionary.hello = "ni hao";
-chineseDictionary.bye = "zai jian";
+chineseDictionary.hello = "你好";
+chineseDictionary.bye = "再见";
 
 alert(Object.keys(chineseDictionary)); // hello,bye
 ```
 
-## Getting all properties
-
-There are many ways to get keys/values from an object.
-
-We already know these ones:
-
-- [Object.keys(obj)](mdn:js/Object/keys) / [Object.values(obj)](mdn:js/Object/values) / [Object.entries(obj)](mdn:js/Object/entries) -- returns an array of enumerable own string property names/values/key-value pairs. These methods only list *enumerable* properties, and those that have *strings as keys*.
-
-If we want symbolic properties:
-
-- [Object.getOwnPropertySymbols(obj)](mdn:js/Object/getOwnPropertySymbols) -- returns an array of all own symbolic property names.
-
-If we want non-enumerable properties:
-
-- [Object.getOwnPropertyNames(obj)](mdn:js/Object/getOwnPropertyNames) -- returns an array of all own string property names.
-
-If we want *all* properties:
-
-- [Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys) -- returns an array of all own property names.
-
-These methods are a bit different about which properties they return, but all of them operate on the object itself. Properties from the prototype are not listed.
-
-The `for..in` loop is different: it loops over inherited properties too.
-
-For instance:
-
-```js run
-let animal = {
-  eats: true
-};
-
-let rabbit = {
-  jumps: true,
-  __proto__: animal
-};
+## Summary
 
-*!*
-// only own keys
-alert(Object.keys(rabbit)); // jumps
-*/!*
+Modern methods to setup and directly access the prototype are:
 
-*!*
-// inherited keys too
-for(let prop in rabbit) alert(prop); // jumps, then eats
-*/!*
-```
+- [Object.create(proto[, descriptors])](mdn:js/Object/create) -- creates an empty object with given `proto` as `[[Prototype]]` (can be `null`) and optional property descriptors.
+- [Object.getPrototypeOf(obj)](mdn:js/Object.getPrototypeOf) -- returns the `[[Prototype]]` of `obj` (same as `__proto__` getter).
+- [Object.setPrototypeOf(obj, proto)](mdn:js/Object.setPrototypeOf) -- sets the `[[Prototype]]` of `obj` to `proto` (same as `__proto__` setter).
 
-If we want to distinguish inherited properties, there's a built-in method [obj.hasOwnProperty(key)](mdn:js/Object/hasOwnProperty): it returns `true` if `obj` has its own (not inherited) property named `key`.
+The built-in `__proto__` getter/setter is unsafe if we'd want to put user-generated keys in to an object. Just because a user may enter "__proto__" as the key, and there'll be an error with hopefully easy, but generally unpredictable consequences.
 
-So we can filter out inherited properties (or do something else with them):
+So we can either use `Object.create(null)` to create a "very plain" object without `__proto__`, or stick to `Map` objects for that.
 
-```js run
-let animal = {
-  eats: true
-};
-
-let rabbit = {
-  jumps: true,
-  __proto__: animal
-};
+Also, `Object.create` provides an easy way to shallow-copy an object with all descriptors:
 
-for(let prop in rabbit) {
-  let isOwn = rabbit.hasOwnProperty(prop);
-  alert(`${prop}: ${isOwn}`); // jumps:true, then eats:false
-}
+```js
+let clone = Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
 ```
-Here we have the following inheritance chain: `rabbit`, then `animal`, then `Object.prototype` (because `animal` is a literal object `{...}`, so it's by default), and then `null` above it:
-
-![](rabbit-animal-object.png)
-
-Note, there's one funny thing. Where is the method `rabbit.hasOwnProperty` coming from? Looking at the chain we can see that the method is provided by `Object.prototype.hasOwnProperty`. In other words, it's inherited.
 
-...But why `hasOwnProperty` does not appear in `for..in` loop, if it lists all inherited properties?  The answer is simple: it's not enumerable. Just like all other properties of `Object.prototype`. That's why they are not listed.
 
-## Summary
-
-Here's a brief list of methods we discussed in this chapter -- as a recap:
-
-- [Object.create(proto[, descriptors])](mdn:js/Object/create) -- creates an empty object with given `proto` as `[[Prototype]]` (can be `null`) and optional property descriptors.
-- [Object.getPrototypeOf(obj)](mdn:js/Object.getPrototypeOf) -- returns the `[[Prototype]]` of `obj` (same as `__proto__` getter).
-- [Object.setPrototypeOf(obj, proto)](mdn:js/Object.setPrototypeOf) -- sets the `[[Prototype]]` of `obj` to `proto` (same as `__proto__` setter).
 - [Object.keys(obj)](mdn:js/Object/keys) / [Object.values(obj)](mdn:js/Object/values) / [Object.entries(obj)](mdn:js/Object/entries) -- returns an array of enumerable own string property names/values/key-value pairs.
 - [Object.getOwnPropertySymbols(obj)](mdn:js/Object/getOwnPropertySymbols) -- returns an array of all own symbolic property names.
 - [Object.getOwnPropertyNames(obj)](mdn:js/Object/getOwnPropertyNames) -- returns an array of all own string property names.
diff --git a/1-js/08-prototypes/04-prototype-methods/object-prototype-2.png b/1-js/08-prototypes/04-prototype-methods/object-prototype-2.png
new file mode 100644
index 000000000..343435af6
Binary files /dev/null and b/1-js/08-prototypes/04-prototype-methods/object-prototype-2.png differ
diff --git a/1-js/08-prototypes/04-prototype-methods/object-prototype-2@2x.png b/1-js/08-prototypes/04-prototype-methods/object-prototype-2@2x.png
new file mode 100644
index 000000000..86b8a678e
Binary files /dev/null and b/1-js/08-prototypes/04-prototype-methods/object-prototype-2@2x.png differ
diff --git a/1-js/08-prototypes/04-prototype-methods/object-prototype-null.png b/1-js/08-prototypes/04-prototype-methods/object-prototype-null.png
new file mode 100644
index 000000000..792c4f423
Binary files /dev/null and b/1-js/08-prototypes/04-prototype-methods/object-prototype-null.png differ
diff --git a/1-js/08-prototypes/04-prototype-methods/object-prototype-null@2x.png b/1-js/08-prototypes/04-prototype-methods/object-prototype-null@2x.png
new file mode 100644
index 000000000..d97efa884
Binary files /dev/null and b/1-js/08-prototypes/04-prototype-methods/object-prototype-null@2x.png differ
diff --git a/1-js/08-prototypes/05-getting-all-properties/article.md b/1-js/08-prototypes/05-getting-all-properties/article.md
new file mode 100644
index 000000000..345181786
--- /dev/null
+++ b/1-js/08-prototypes/05-getting-all-properties/article.md
@@ -0,0 +1,83 @@
+
+# Getting all properties
+
+There are many ways to get keys/values from an object.
+
+Most of them operate on the object itself, excluding the prototype, let's recall them:
+
+- [Object.keys(obj)](mdn:js/Object/keys) / [Object.values(obj)](mdn:js/Object/values) / [Object.entries(obj)](mdn:js/Object/entries) -- returns an array of enumerable own string property names/values/key-value pairs. These methods only list *enumerable* properties, and those that have *strings as keys*.
+
+If we want symbolic properties:
+
+- [Object.getOwnPropertySymbols(obj)](mdn:js/Object/getOwnPropertySymbols) -- returns an array of all own symbolic property names.
+
+If we want non-enumerable properties:
+
+- [Object.getOwnPropertyNames(obj)](mdn:js/Object/getOwnPropertyNames) -- returns an array of all own string property names.
+
+If we want *all* properties:
+
+- [Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys) -- returns an array of all own property names.
+
+These methods are a bit different about which properties they return, but all of them operate on the object itself. Properties from the prototype are not listed.
+
+## for..in loop
+
+The `for..in` loop is different: it loops over inherited properties too.
+
+For instance:
+
+```js run
+let animal = {
+  eats: true
+};
+
+let rabbit = {
+  jumps: true,
+  __proto__: animal
+};
+
+*!*
+// only own keys
+alert(Object.keys(rabbit)); // jumps
+*/!*
+
+*!*
+// inherited keys too
+for(let prop in rabbit) alert(prop); // jumps, then eats
+*/!*
+```
+
+If that's not what we want, and we'd like to exclude inherited properties, there's a built-in method [obj.hasOwnProperty(key)](mdn:js/Object/hasOwnProperty): it returns `true` if `obj` has its own (not inherited) property named `key`.
+
+So we can filter out inherited properties (or do something else with them):
+
+```js run
+let animal = {
+  eats: true
+};
+
+let rabbit = {
+  jumps: true,
+  __proto__: animal
+};
+
+for(let prop in rabbit) {
+  let isOwn = rabbit.hasOwnProperty(prop);
+  alert(`${prop}: ${isOwn}`); // jumps: true, then eats: false
+}
+```
+
+Here we have the following inheritance chain: `rabbit`, then `animal`, then `Object.prototype` (because `animal` is a literal object `{...}`, so it's by default), and then `null` above it:
+
+![](rabbit-animal-object.png)
+
+Note, there's one funny thing. Where is the method `rabbit.hasOwnProperty` coming from? Looking at the chain we can see that the method is provided by `Object.prototype.hasOwnProperty`. In other words, it's inherited.
+
+...But why `hasOwnProperty` does not appear in `for..in` loop, if it lists all inherited properties?  The answer is simple: it's not enumerable. Just like all other properties of `Object.prototype`. That's why they are not listed.
+
+## Summary
+
+Most methods ignore inherited properties, with a notable exception of `for..in`.
+
+For the latter we can use [obj.hasOwnProperty(key)](mdn:js/Object/hasOwnProperty): it returns `true` if `obj` has its own (not inherited) property named `key`.
diff --git a/1-js/08-prototypes/05-getting-all-properties/rabbit-animal-object.png b/1-js/08-prototypes/05-getting-all-properties/rabbit-animal-object.png
new file mode 100644
index 000000000..3924233dd
Binary files /dev/null and b/1-js/08-prototypes/05-getting-all-properties/rabbit-animal-object.png differ
diff --git a/1-js/08-prototypes/05-getting-all-properties/rabbit-animal-object@2x.png b/1-js/08-prototypes/05-getting-all-properties/rabbit-animal-object@2x.png
new file mode 100644
index 000000000..5350a1935
Binary files /dev/null and b/1-js/08-prototypes/05-getting-all-properties/rabbit-animal-object@2x.png differ
diff --git a/1-js/08-prototypes/index.md b/1-js/08-prototypes/index.md
new file mode 100644
index 000000000..8554a0e30
--- /dev/null
+++ b/1-js/08-prototypes/index.md
@@ -0,0 +1 @@
+# Prototypes, inheritance
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/source.view/clock.js b/1-js/09-classes/01-class/1-rewrite-to-class/_js.view/solution.js
similarity index 64%
rename from 1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/source.view/clock.js
rename to 1-js/09-classes/01-class/1-rewrite-to-class/_js.view/solution.js
index 8009273e3..0b31cf334 100644
--- a/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/source.view/clock.js
+++ b/1-js/09-classes/01-class/1-rewrite-to-class/_js.view/solution.js
@@ -1,9 +1,9 @@
 class Clock {
   constructor({ template }) {
-    this._template = template;
+    this.template = template;
   }
 
-  _render() {
+  render() {
     let date = new Date();
 
     let hours = date.getHours();
@@ -15,7 +15,7 @@ class Clock {
     let secs = date.getSeconds();
     if (secs < 10) secs = '0' + secs;
 
-    let output = this._template
+    let output = this.template
       .replace('h', hours)
       .replace('m', mins)
       .replace('s', secs);
@@ -24,11 +24,15 @@ class Clock {
   }
 
   stop() {
-    clearInterval(this._timer);
+    clearInterval(this.timer);
   }
 
   start() {
-    this._render();
-    this._timer = setInterval(() => this._render(), 1000);
+    this.render();
+    this.timer = setInterval(() => this.render(), 1000);
   }
 }
+
+
+let clock = new Clock({template: 'h:m:s'});
+clock.start();
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/source.view/clock.js b/1-js/09-classes/01-class/1-rewrite-to-class/_js.view/source.js
similarity index 90%
rename from 1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/source.view/clock.js
rename to 1-js/09-classes/01-class/1-rewrite-to-class/_js.view/source.js
index c4bfaa0ff..f1749c8ba 100644
--- a/1-js/07-object-oriented-programming/08-class-patterns/2-rewrite-to-prototypes/source.view/clock.js
+++ b/1-js/09-classes/01-class/1-rewrite-to-class/_js.view/source.js
@@ -32,3 +32,6 @@ function Clock({ template }) {
   };
 
 }
+
+let clock = new Clock({template: 'h:m:s'});
+clock.start();
diff --git a/1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/solution.md b/1-js/09-classes/01-class/1-rewrite-to-class/solution.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/solution.md
rename to 1-js/09-classes/01-class/1-rewrite-to-class/solution.md
diff --git a/1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/task.md b/1-js/09-classes/01-class/1-rewrite-to-class/task.md
similarity index 53%
rename from 1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/task.md
rename to 1-js/09-classes/01-class/1-rewrite-to-class/task.md
index a29d347f5..05365e410 100644
--- a/1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/task.md
+++ b/1-js/09-classes/01-class/1-rewrite-to-class/task.md
@@ -4,6 +4,6 @@ importance: 5
 
 # Rewrite to class
 
-Rewrite the `Clock` class from prototypes to the modern "class" syntax.
+The `Clock` class is written in functional style. Rewrite it the "class" syntax.
 
 P.S. The clock ticks in the console, open it to see.
diff --git a/1-js/09-classes/01-class/article.md b/1-js/09-classes/01-class/article.md
new file mode 100644
index 000000000..16ff9c666
--- /dev/null
+++ b/1-js/09-classes/01-class/article.md
@@ -0,0 +1,368 @@
+
+# Class basic syntax
+
+```quote author="Wikipedia"
+In object-oriented programming, a *class* is an extensible program-code-template for creating objects, providing initial values for state (member variables) and implementations of behavior (member functions or methods).
+```
+
+In practice, we often need to create many objects of the same kind, like users, or goods or whatever.
+
+As we already know from the chapter <info:constructor-new>, `new function` can help with that.
+
+But in the modern JavaScript, there's a more advanced "class" construct, that introduces great new features which are useful for object-oriented programming.
+
+## The "class" syntax
+
+The basic syntax is:
+```js
+class MyClass {
+  // class methods
+  constructor() { ... }
+  method1() { ... }
+  method2() { ... }
+  method3() { ... }
+  ...
+}
+```
+
+Then `new MyClass()` creates a new object with all the listed methods.
+
+The `constructor()` method is called automatically by `new`, so we can initialize the object there.
+
+For example:
+
+```js run
+class User {
+
+  constructor(name) {
+    this.name = name;
+  }
+
+  sayHi() {
+    alert(this.name);
+  }
+
+}
+
+// Usage:
+let user = new User("John");
+user.sayHi();
+```
+
+When `new User("John")` is called:
+1. A new object is created.
+2. The `constructor` runs with the given argument and assigns `this.name` to it.
+
+...Then we can call methods, such as `user.sayHi`.
+
+
+```warn header="No comma between class methods"
+A common pitfall for novice developers is to put a comma between class methods, which would result in a syntax error.
+
+The notation here is not to be confused with object literals. Within the class, no commas are required.
+```
+
+## What is a class?
+
+So, what exactly is a `class`? That's not an entirely  new language-level entity, as one might think.
+
+Let's unveil any magic and see what a class really is. That'll help in understanding many complex aspects.
+
+In JavaScript, a class is a kind of a function.
+
+Here, take a look:
+
+```js run
+class User {
+  constructor(name) { this.name = name; }
+  sayHi() { alert(this.name); }
+}
+
+// proof: User is a function
+*!*
+alert(typeof User); // function
+*/!*
+```
+
+What `class User {...}` construct really does is:
+1. Creates a function named `User`, that becomes the result of the class declaration.
+    - The function code is taken from the `constructor` method (assumed empty is we don't write such method).
+3. Stores all methods, such as `sayHi`, in `User.prototype`.
+
+Afterwards, for new objects, when we call a method, it's taken from the prototype, just as  described in the chapter <info:function-prototype>. So `new User` object has access to class methods.
+
+We can illustrate the result of `class User` as:
+
+![](class-user.png)
+
+Here's the code to introspect it:
+
+
+```js run
+class User {
+  constructor(name) { this.name = name; }
+  sayHi() { alert(this.name); }
+}
+
+// class is a function
+alert(typeof User); // function
+
+// ...or, more precisely, the constructor method
+alert(User === User.prototype.constructor); // true
+
+// The methods are in User.prototype, e.g:
+alert(User.prototype.sayHi); // alert(this.name);
+
+// there are exactly two methods in the prototype
+alert(Object.getOwnPropertyNames(User.prototype)); // constructor, sayHi
+```
+
+## Not just a syntax sugar
+
+Sometimes people say that `class` is a "syntax sugar" in JavaScript, because we could actually declare the same without `class` keyword at all:
+
+```js run
+// rewriting class User in pure functions
+
+// 1. Create constructor function
+function User(name) {
+  this.name = name;
+}
+// any function prototype has constructor property by default,
+// so we don't need to create it
+
+// 2. Add the method to prototype
+User.prototype.sayHi = function() {
+  alert(this.name);
+};
+
+// Usage:
+let user = new User("John");
+user.sayHi();
+```
+
+The result of this definition is about the same. So, there are indeed reasons why `class` can be considered a syntax sugar to define a constructor together with its prototype methods.
+
+Although, there are important differences.
+
+1. First, a function created by `class` is labelled by a special internal property `[[FunctionKind]]:"classConstructor"`. So it's not entirely the same as creating it manually.
+
+    Unlike a regular function, a class constructor can't be called without `new`:
+
+    ```js run
+    class User {
+      constructor() {}
+    }
+
+    alert(typeof User); // function
+    User(); // Error: Class constructor User cannot be invoked without 'new'
+    ```
+
+    Also, a string representation of a class constructor in most JavaScript engines starts with the "class..."
+
+    ```js run
+    class User {
+      constructor() {}
+    }
+
+    alert(User); // class User { ... }
+    ```
+
+2. Class methods are non-enumerable
+    A class definition sets `enumerable` flag to `false` for all methods in the `"prototype"`.
+
+    That's good, because if we `for..in` over an object, we usually don't want its class methods.
+
+3. Classes always `use strict`
+    All code inside the class construct is automatically in strict mode.
+
+
+Also, in addition to its basic operation, the `class` syntax brings many other features with it which we'll explore later.
+
+## Class Expression
+
+Just like functions, classes can be defined inside another expression, passed around, returned, assigned etc.
+
+Here's an example of a class expression:
+
+```js
+let User = class {
+  sayHi() {
+    alert("Hello");
+  }
+};
+```
+
+Similar to Named Function Expressions, class expressions may or may not have a name.
+
+If a class expression has a name, it's visible inside the class only:
+
+```js run
+// "Named Class Expression" (alas, no such term, but that's what's going on)
+let User = class *!*MyClass*/!* {
+  sayHi() {
+    alert(MyClass); // MyClass is visible only inside the class
+  }
+};
+
+new User().sayHi(); // works, shows MyClass definition
+
+alert(MyClass); // error, MyClass not visible outside of the class
+```
+
+
+We can even make classes dynamically "on-demand", like this:
+
+```js run
+function makeClass(phrase) {
+  // declare a class and return it
+  return class {
+    sayHi() {
+      alert(phrase);
+    };
+  };
+}
+
+// Create a new class
+let User = makeClass("Hello");
+
+new User().sayHi(); // Hello
+```
+
+
+## Getters/setters, other shorthands
+
+Classes also include getters/setters, generators, computed properties etc.
+
+Here's an example for `user.name` implemented using `get/set`:
+
+```js run
+class User {
+
+  constructor(name) {
+    // invokes the setter
+    this._name = name;
+  }
+
+*!*
+  get name() {
+*/!*
+    return this._name;
+  }
+
+*!*
+  set name(value) {
+*/!*
+    if (value.length < 4) {
+      alert("Name is too short.");
+      return;
+    }
+    this._name = value;
+  }
+
+}
+
+let user = new User("John");
+alert(user.name); // John
+
+user = new User(""); // Name too short.
+```
+
+Internally, getters and setters are created on `User.prototype`, like this:
+
+```js
+Object.defineProperties(User.prototype, {
+  name: {
+    get() {
+      return this._name
+    },
+    set(name) {
+      // ...
+    }
+  }
+});
+```
+
+Here's an example with computed properties:
+
+```js run
+function f() { return "sayHi"; }
+
+class User {
+  [f()]() {
+    alert("Hello");
+  }
+
+}
+
+new User().sayHi();
+```
+
+For a generator method, similarly, prepend it with `*`.
+
+## Class properties
+
+```warn header="Old browsers may need a polyfill"
+Class-level properties are a recent addition to the language.
+```
+
+In the example above, `User` only had methods. Let's add a property:
+
+```js run
+class User {
+  name = "Anonymous";
+
+  sayHi() {
+    alert(`Hello, ${this.name}!`);
+  }
+}
+
+new User().sayHi();
+```
+
+The property is not placed into `User.prototype`. Instead, it is created by `new`, separately for every object. So, the property will never be shared between different objects of the same class.
+
+
+## Summary
+
+JavaScript provides many ways to create a class.
+
+First, as per the general object-oriented terminology, a class is something that provides "object templates", allows to create same-structured objects.
+
+When we say "a class", that doesn't necessary means the `class` keyword.
+
+This is a class:
+
+```js
+function User(name) {
+  this.sayHi = function() {
+    alert(name);
+  }
+}
+```
+
+...But in most cases `class` keyword is used, as it provides great syntax and many additional features.
+
+The basic class syntax looks like this:
+
+```js
+class MyClass {
+  prop = value; // field
+
+  constructor(...) { // constructor
+    // ...
+  }
+
+  method(...) {} // method
+
+  get something(...) {} // getter method
+  set something(...) {} // setter method
+
+  [Symbol.iterator]() {} // method with computed name/symbol name
+  // ...
+}
+```
+
+`MyClass` is technically a function, while methods are written to `MyClass.prototype`.
+
+In the next chapters we'll learn more about classes, including inheritance and other features.
diff --git a/1-js/09-classes/01-class/class-user.png b/1-js/09-classes/01-class/class-user.png
new file mode 100644
index 000000000..dc8b75679
Binary files /dev/null and b/1-js/09-classes/01-class/class-user.png differ
diff --git a/1-js/09-classes/01-class/class-user@2x.png b/1-js/09-classes/01-class/class-user@2x.png
new file mode 100644
index 000000000..aaa53708f
Binary files /dev/null and b/1-js/09-classes/01-class/class-user@2x.png differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/1-class-constructor-error/solution.md b/1-js/09-classes/02-class-inheritance/1-class-constructor-error/solution.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/10-class-inheritance/1-class-constructor-error/solution.md
rename to 1-js/09-classes/02-class-inheritance/1-class-constructor-error/solution.md
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/1-class-constructor-error/task.md b/1-js/09-classes/02-class-inheritance/1-class-constructor-error/task.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/10-class-inheritance/1-class-constructor-error/task.md
rename to 1-js/09-classes/02-class-inheritance/1-class-constructor-error/task.md
diff --git a/1-js/09-classes/02-class-inheritance/2-clock-class-extended/solution.md b/1-js/09-classes/02-class-inheritance/2-clock-class-extended/solution.md
new file mode 100644
index 000000000..dcb4ffe59
--- /dev/null
+++ b/1-js/09-classes/02-class-inheritance/2-clock-class-extended/solution.md
@@ -0,0 +1 @@
+[js src="solution.view/extended-clock.js"]
diff --git a/1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/solution.view/clock.js b/1-js/09-classes/02-class-inheritance/2-clock-class-extended/solution.view/clock.js
similarity index 70%
rename from 1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/solution.view/clock.js
rename to 1-js/09-classes/02-class-inheritance/2-clock-class-extended/solution.view/clock.js
index 8009273e3..d701c0cae 100644
--- a/1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/solution.view/clock.js
+++ b/1-js/09-classes/02-class-inheritance/2-clock-class-extended/solution.view/clock.js
@@ -1,9 +1,9 @@
 class Clock {
   constructor({ template }) {
-    this._template = template;
+    this.template = template;
   }
 
-  _render() {
+  render() {
     let date = new Date();
 
     let hours = date.getHours();
@@ -15,7 +15,7 @@ class Clock {
     let secs = date.getSeconds();
     if (secs < 10) secs = '0' + secs;
 
-    let output = this._template
+    let output = this.template
       .replace('h', hours)
       .replace('m', mins)
       .replace('s', secs);
@@ -24,11 +24,11 @@ class Clock {
   }
 
   stop() {
-    clearInterval(this._timer);
+    clearInterval(this.timer);
   }
 
   start() {
-    this._render();
-    this._timer = setInterval(() => this._render(), 1000);
+    this.render();
+    this.timer = setInterval(() => this.render(), 1000);
   }
 }
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/solution.view/extended-clock.js b/1-js/09-classes/02-class-inheritance/2-clock-class-extended/solution.view/extended-clock.js
similarity index 53%
rename from 1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/solution.view/extended-clock.js
rename to 1-js/09-classes/02-class-inheritance/2-clock-class-extended/solution.view/extended-clock.js
index 4eb12381f..ca613ca5e 100644
--- a/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/solution.view/extended-clock.js
+++ b/1-js/09-classes/02-class-inheritance/2-clock-class-extended/solution.view/extended-clock.js
@@ -2,11 +2,11 @@ class ExtendedClock extends Clock {
   constructor(options) {
     super(options);
     let { precision=1000 } = options;
-    this._precision = precision;
+    this.precision = precision;
   }
 
   start() {
-    this._render();
-    this._timer = setInterval(() => this._render(), this._precision);
+    this.render();
+    this.timer = setInterval(() => this.render(), this.precision);
   }
 };
diff --git a/1-js/09-classes/02-class-inheritance/2-clock-class-extended/solution.view/index.html b/1-js/09-classes/02-class-inheritance/2-clock-class-extended/solution.view/index.html
new file mode 100644
index 000000000..f76a43623
--- /dev/null
+++ b/1-js/09-classes/02-class-inheritance/2-clock-class-extended/solution.view/index.html
@@ -0,0 +1,12 @@
+<!DOCTYPE HTML>
+<script src="clock.js"></script>
+<script src="extended-clock.js"></script>
+
+<script>
+  let lowResolutionClock = new ExtendedClock({
+    template: 'h:m:s',
+    precision: 10000
+  });
+
+  lowResolutionClock.start();
+</script>
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/solution.view/clock.js b/1-js/09-classes/02-class-inheritance/2-clock-class-extended/source.view/clock.js
similarity index 70%
rename from 1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/solution.view/clock.js
rename to 1-js/09-classes/02-class-inheritance/2-clock-class-extended/source.view/clock.js
index 8009273e3..d701c0cae 100644
--- a/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/solution.view/clock.js
+++ b/1-js/09-classes/02-class-inheritance/2-clock-class-extended/source.view/clock.js
@@ -1,9 +1,9 @@
 class Clock {
   constructor({ template }) {
-    this._template = template;
+    this.template = template;
   }
 
-  _render() {
+  render() {
     let date = new Date();
 
     let hours = date.getHours();
@@ -15,7 +15,7 @@ class Clock {
     let secs = date.getSeconds();
     if (secs < 10) secs = '0' + secs;
 
-    let output = this._template
+    let output = this.template
       .replace('h', hours)
       .replace('m', mins)
       .replace('s', secs);
@@ -24,11 +24,11 @@ class Clock {
   }
 
   stop() {
-    clearInterval(this._timer);
+    clearInterval(this.timer);
   }
 
   start() {
-    this._render();
-    this._timer = setInterval(() => this._render(), 1000);
+    this.render();
+    this.timer = setInterval(() => this.render(), 1000);
   }
 }
diff --git a/1-js/09-classes/02-class-inheritance/2-clock-class-extended/source.view/index.html b/1-js/09-classes/02-class-inheritance/2-clock-class-extended/source.view/index.html
new file mode 100644
index 000000000..c0609858b
--- /dev/null
+++ b/1-js/09-classes/02-class-inheritance/2-clock-class-extended/source.view/index.html
@@ -0,0 +1,21 @@
+<!DOCTYPE HTML>
+<script src="clock.js"></script>
+<script>
+  let clock = new Clock({
+    template: 'h:m:s'
+  });
+  clock.start();
+
+
+  /* Your class should work like this: */
+
+  /*
+
+    let lowResolutionClock = new ExtendedClock({
+      template: 'h:m:s',
+      precision: 10000
+    });
+
+    lowResolutionClock.start();
+  */
+</script>
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/task.md b/1-js/09-classes/02-class-inheritance/2-clock-class-extended/task.md
similarity index 92%
rename from 1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/task.md
rename to 1-js/09-classes/02-class-inheritance/2-clock-class-extended/task.md
index 05da45387..bbc2c6a43 100644
--- a/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/task.md
+++ b/1-js/09-classes/02-class-inheritance/2-clock-class-extended/task.md
@@ -6,6 +6,9 @@ importance: 5
 
 We've got a `Clock` class. As of now, it prints the time every second.
 
+
+[js src="source.view/clock.js"]
+
 Create a new class `ExtendedClock` that inherits from `Clock` and adds the parameter `precision` -- the number of `ms` between "ticks". Should be `1000` (1 second) by default.
 
 - Your code should be in the file `extended-clock.js`
diff --git a/1-js/09-classes/02-class-inheritance/3-class-extend-object/rabbit-extends-object.png b/1-js/09-classes/02-class-inheritance/3-class-extend-object/rabbit-extends-object.png
new file mode 100644
index 000000000..c610e28c3
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/3-class-extend-object/rabbit-extends-object.png differ
diff --git a/1-js/09-classes/02-class-inheritance/3-class-extend-object/rabbit-extends-object@2x.png b/1-js/09-classes/02-class-inheritance/3-class-extend-object/rabbit-extends-object@2x.png
new file mode 100644
index 000000000..4819c7f79
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/3-class-extend-object/rabbit-extends-object@2x.png differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/solution.md b/1-js/09-classes/02-class-inheritance/3-class-extend-object/solution.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/solution.md
rename to 1-js/09-classes/02-class-inheritance/3-class-extend-object/solution.md
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/task.md b/1-js/09-classes/02-class-inheritance/3-class-extend-object/task.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/task.md
rename to 1-js/09-classes/02-class-inheritance/3-class-extend-object/task.md
diff --git a/1-js/09-classes/02-class-inheritance/animal-rabbit-extends.png b/1-js/09-classes/02-class-inheritance/animal-rabbit-extends.png
new file mode 100644
index 000000000..0d887dbc0
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/animal-rabbit-extends.png differ
diff --git a/1-js/09-classes/02-class-inheritance/animal-rabbit-extends@2x.png b/1-js/09-classes/02-class-inheritance/animal-rabbit-extends@2x.png
new file mode 100644
index 000000000..af09271a9
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/animal-rabbit-extends@2x.png differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md
similarity index 72%
rename from 1-js/07-object-oriented-programming/10-class-inheritance/article.md
rename to 1-js/09-classes/02-class-inheritance/article.md
index 2c44e5ead..7d00d9bd1 100644
--- a/1-js/07-object-oriented-programming/10-class-inheritance/article.md
+++ b/1-js/09-classes/02-class-inheritance/article.md
@@ -1,7 +1,53 @@
 
-# Class inheritance, super
+# Class inheritance
 
-Classes can extend one another. There's a nice syntax, technically based on the prototypal inheritance.
+Let's say we have two classes.
+
+`Animal`:
+
+```js
+class Animal {
+  constructor(name) {
+    this.speed = 0;
+    this.name = name;
+  }
+  run(speed) {
+    this.speed += speed;
+    alert(`${this.name} runs with speed ${this.speed}.`);
+  }
+  stop() {
+    this.speed = 0;
+    alert(`${this.name} stopped.`);
+  }
+}
+
+let animal = new Animal("My animal");
+```
+
+![](rabbit-animal-independent-animal.png)
+
+
+...And `Rabbit`:
+
+```js
+class Rabbit {
+  constructor(name) {
+    this.name = name;
+  }
+  hide() {
+    alert(`${this.name} hides!`);
+  }
+}
+
+let rabbit = new Rabbit("My rabbit");
+```
+
+![](rabbit-animal-independent-rabbit.png)
+
+
+Right now they are fully independent.
+
+But we'd want `Rabbit` to extend `Animal`. In other words, rabbits should be based on animals, have access to methods of `Animal` and extend them with its own methods.
 
 To inherit from another class, we should specify `"extends"` and the parent class before the brackets `{..}`.
 
@@ -9,32 +55,28 @@ Here `Rabbit` inherits from `Animal`:
 
 ```js run
 class Animal {
-
   constructor(name) {
     this.speed = 0;
     this.name = name;
   }
-
   run(speed) {
     this.speed += speed;
     alert(`${this.name} runs with speed ${this.speed}.`);
   }
-
   stop() {
     this.speed = 0;
     alert(`${this.name} stopped.`);
   }
-
 }
 
+// Inherit from Animal by specifying "extends Animal"
 *!*
-// Inherit from Animal
 class Rabbit extends Animal {
+*/!*
   hide() {
     alert(`${this.name} hides!`);
   }
 }
-*/!*
 
 let rabbit = new Rabbit("White Rabbit");
 
@@ -42,11 +84,15 @@ rabbit.run(5); // White Rabbit runs with speed 5.
 rabbit.hide(); // White Rabbit hides!
 ```
 
-The `extends` keyword actually adds a `[[Prototype]]` reference from `Rabbit.prototype` to `Animal.prototype`, just as you expect it to be, and as we've seen before.
+Now the `Rabbit` code became a bit shorter, as it uses `Animal` constructor by default, and it also can `run`, as animals do.
+
+Internally, `extends` keyword adds `[[Prototype]]` reference from `Rabbit.prototype` to `Animal.prototype`:
 
 ![](animal-rabbit-extends.png)
 
-So now `rabbit` has access both to its own methods and to methods of `Animal`.
+So, if a method is not found in `Rabbit.prototype`, JavaScript takes it from `Animal.prototype`.
+
+As we can recall from the chapter <info:native-prototypes>, JavaScript uses the same prototypal inheritance for build-in objects. E.g. `Date.prototype.[[Prototype]]` is `Object.prototype`, so dates have generic object methods.
 
 ````smart header="Any expression is allowed after `extends`"
 Class syntax allows to specify not just a class, but any expression after `extends`.
@@ -429,147 +475,3 @@ let rabbit = {
 rabbit.eat();  // Error calling super (because there's no [[HomeObject]])
 */!*
 ```
-
-## Static methods and inheritance
-
-The `class` syntax supports inheritance for static properties too.
-
-For instance:
-
-```js run
-class Animal {
-
-  constructor(name, speed) {
-    this.speed = speed;
-    this.name = name;
-  }
-
-  run(speed = 0) {
-    this.speed += speed;
-    alert(`${this.name} runs with speed ${this.speed}.`);
-  }
-
-  static compare(animalA, animalB) {
-    return animalA.speed - animalB.speed;
-  }
-
-}
-
-// Inherit from Animal
-class Rabbit extends Animal {
-  hide() {
-    alert(`${this.name} hides!`);
-  }
-}
-
-let rabbits = [
-  new Rabbit("White Rabbit", 10),
-  new Rabbit("Black Rabbit", 5)
-];
-
-rabbits.sort(Rabbit.compare);
-
-rabbits[0].run(); // Black Rabbit runs with speed 5.
-```
-
-Now we can call `Rabbit.compare` assuming that the inherited `Animal.compare` will be called.
-
-How does it work? Again, using prototypes. As you might have already guessed, extends also gives `Rabbit` the `[[Prototype]]` reference to `Animal`.
-
-
-![](animal-rabbit-static.png)
-
-So, `Rabbit` function now inherits from `Animal` function. And `Animal` function normally has `[[Prototype]]` referencing `Function.prototype`, because it doesn't `extend` anything.
-
-Here, let's check that:
-
-```js run
-class Animal {}
-class Rabbit extends Animal {}
-
-// for static propertites and methods
-alert(Rabbit.__proto__ === Animal); // true
-
-// and the next step is Function.prototype
-alert(Animal.__proto__ === Function.prototype); // true
-
-// that's in addition to the "normal" prototype chain for object methods
-alert(Rabbit.prototype.__proto__ === Animal.prototype);
-```
-
-This way `Rabbit` has access to all static methods of `Animal`.
-
-### No static inheritance in built-ins
-
-Please note that built-in classes don't have such static `[[Prototype]]` reference. For instance, `Object` has `Object.defineProperty`, `Object.keys` and so on, but `Array`, `Date` etc do not inherit them.
-
-Here's the picture structure for `Date` and `Object`:
-
-![](object-date-inheritance.png)
-
-Note, there's no link between `Date` and `Object`. Both `Object` and `Date` exist independently. `Date.prototype` inherits from `Object.prototype`, but that's all.
-
-Such difference exists for historical reasons: there was no thought about class syntax and inheriting static methods at the dawn of JavaScript language.
-
-## Natives are extendable
-
-Built-in classes like Array, Map and others are extendable also.
-
-For instance, here `PowerArray` inherits from the native `Array`:
-
-```js run
-// add one more method to it (can do more)
-class PowerArray extends Array {
-  isEmpty() {
-    return this.length === 0;
-  }
-}
-
-let arr = new PowerArray(1, 2, 5, 10, 50);
-alert(arr.isEmpty()); // false
-
-let filteredArr = arr.filter(item => item >= 10);
-alert(filteredArr); // 10, 50
-alert(filteredArr.isEmpty()); // false
-```
-
-Please note one very interesting thing. Built-in methods like `filter`, `map` and others -- return new objects of exactly the inherited type. They rely on the `constructor` property to do so.
-
-In the example above,
-```js
-arr.constructor === PowerArray
-```
-
-So when `arr.filter()` is called, it internally creates the new array of results exactly as `new PowerArray`. And we can keep using its methods further down the chain.
-
-Even more, we can customize that behavior. The static getter `Symbol.species`, if exists, returns the constructor to use in such cases.
-
-For example, here due to `Symbol.species` built-in methods like `map`, `filter` will return "normal" arrays:
-
-```js run
-class PowerArray extends Array {
-  isEmpty() {
-    return this.length === 0;
-  }
-
-*!*
-  // built-in methods will use this as the constructor
-  static get [Symbol.species]() {
-    return Array;
-  }
-*/!*
-}
-
-let arr = new PowerArray(1, 2, 5, 10, 50);
-alert(arr.isEmpty()); // false
-
-// filter creates new array using arr.constructor[Symbol.species] as constructor
-let filteredArr = arr.filter(item => item >= 10);
-
-*!*
-// filteredArr is not PowerArray, but Array
-*/!*
-alert(filteredArr.isEmpty()); // Error: filteredArr.isEmpty is not a function
-```
-
-We can use it in more advanced keys to strip extended functionality from resulting values if not needed. Or, maybe, to extend it even further.
diff --git a/1-js/09-classes/02-class-inheritance/class-inheritance-array-object.png b/1-js/09-classes/02-class-inheritance/class-inheritance-array-object.png
new file mode 100644
index 000000000..8d30622ce
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/class-inheritance-array-object.png differ
diff --git a/1-js/09-classes/02-class-inheritance/class-inheritance-array-object@2x.png b/1-js/09-classes/02-class-inheritance/class-inheritance-array-object@2x.png
new file mode 100644
index 000000000..00f6bd80d
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/class-inheritance-array-object@2x.png differ
diff --git a/1-js/09-classes/02-class-inheritance/class-inheritance-rabbit-animal-2.png b/1-js/09-classes/02-class-inheritance/class-inheritance-rabbit-animal-2.png
new file mode 100644
index 000000000..f8afbbcd6
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/class-inheritance-rabbit-animal-2.png differ
diff --git a/1-js/09-classes/02-class-inheritance/class-inheritance-rabbit-animal-2@2x.png b/1-js/09-classes/02-class-inheritance/class-inheritance-rabbit-animal-2@2x.png
new file mode 100644
index 000000000..cf5aa6554
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/class-inheritance-rabbit-animal-2@2x.png differ
diff --git a/1-js/09-classes/02-class-inheritance/class-inheritance-rabbit-animal.png b/1-js/09-classes/02-class-inheritance/class-inheritance-rabbit-animal.png
new file mode 100644
index 000000000..a6f8964e6
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/class-inheritance-rabbit-animal.png differ
diff --git a/1-js/09-classes/02-class-inheritance/class-inheritance-rabbit-animal@2x.png b/1-js/09-classes/02-class-inheritance/class-inheritance-rabbit-animal@2x.png
new file mode 100644
index 000000000..2e3f4d7ff
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/class-inheritance-rabbit-animal@2x.png differ
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/class-inheritance-rabbit-run-animal.png b/1-js/09-classes/02-class-inheritance/class-inheritance-rabbit-run-animal.png
similarity index 100%
rename from 1-js/07-object-oriented-programming/10-class-inheritance/class-inheritance-rabbit-run-animal.png
rename to 1-js/09-classes/02-class-inheritance/class-inheritance-rabbit-run-animal.png
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/class-inheritance-rabbit-run-animal@2x.png b/1-js/09-classes/02-class-inheritance/class-inheritance-rabbit-run-animal@2x.png
similarity index 100%
rename from 1-js/07-object-oriented-programming/10-class-inheritance/class-inheritance-rabbit-run-animal@2x.png
rename to 1-js/09-classes/02-class-inheritance/class-inheritance-rabbit-run-animal@2x.png
diff --git a/1-js/09-classes/02-class-inheritance/rabbit-animal-independent-animal.png b/1-js/09-classes/02-class-inheritance/rabbit-animal-independent-animal.png
new file mode 100644
index 000000000..79351a754
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/rabbit-animal-independent-animal.png differ
diff --git a/1-js/09-classes/02-class-inheritance/rabbit-animal-independent-animal@2x.png b/1-js/09-classes/02-class-inheritance/rabbit-animal-independent-animal@2x.png
new file mode 100644
index 000000000..346574e0c
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/rabbit-animal-independent-animal@2x.png differ
diff --git a/1-js/09-classes/02-class-inheritance/rabbit-animal-independent-rabbit.png b/1-js/09-classes/02-class-inheritance/rabbit-animal-independent-rabbit.png
new file mode 100644
index 000000000..3d3b78cca
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/rabbit-animal-independent-rabbit.png differ
diff --git a/1-js/09-classes/02-class-inheritance/rabbit-animal-independent-rabbit@2x.png b/1-js/09-classes/02-class-inheritance/rabbit-animal-independent-rabbit@2x.png
new file mode 100644
index 000000000..a923d10e5
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/rabbit-animal-independent-rabbit@2x.png differ
diff --git a/1-js/09-classes/02-class-inheritance/this-super-loop.png b/1-js/09-classes/02-class-inheritance/this-super-loop.png
new file mode 100644
index 000000000..e68ed70e7
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/this-super-loop.png differ
diff --git a/1-js/09-classes/02-class-inheritance/this-super-loop@2x.png b/1-js/09-classes/02-class-inheritance/this-super-loop@2x.png
new file mode 100644
index 000000000..037d07587
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/this-super-loop@2x.png differ
diff --git a/1-js/09-classes/03-static-properties-methods/animal-rabbit-static.png b/1-js/09-classes/03-static-properties-methods/animal-rabbit-static.png
new file mode 100644
index 000000000..c5e7e3e49
Binary files /dev/null and b/1-js/09-classes/03-static-properties-methods/animal-rabbit-static.png differ
diff --git a/1-js/09-classes/03-static-properties-methods/animal-rabbit-static@2x.png b/1-js/09-classes/03-static-properties-methods/animal-rabbit-static@2x.png
new file mode 100644
index 000000000..de434af2c
Binary files /dev/null and b/1-js/09-classes/03-static-properties-methods/animal-rabbit-static@2x.png differ
diff --git a/1-js/09-classes/03-static-properties-methods/article.md b/1-js/09-classes/03-static-properties-methods/article.md
new file mode 100644
index 000000000..73a22a79f
--- /dev/null
+++ b/1-js/09-classes/03-static-properties-methods/article.md
@@ -0,0 +1,226 @@
+
+# Static properties and methods
+
+We can also assign a method to the class function, not to its `"prototype"`. Such methods are called *static*.
+
+An example:
+
+```js run
+class User {
+*!*
+  static staticMethod() {
+*/!*
+    alert(this === User);
+  }
+}
+
+User.staticMethod(); // true
+```
+
+That actually does the same as assigning it as a function property:
+
+```js
+function User() { }
+
+User.staticMethod = function() {
+  alert(this === User);
+};
+```
+
+The value of `this` inside `User.staticMethod()` is the class constructor `User` itself (the "object before dot" rule).
+
+Usually, static methods are used to implement functions that belong to the class, but not to any particular object of it.
+
+For instance, we have `Article` objects and need a function to compare them. The natural choice would be `Article.compare`, like this:
+
+```js run
+class Article {
+  constructor(title, date) {
+    this.title = title;
+    this.date = date;
+  }
+
+*!*
+  static compare(articleA, articleB) {
+    return articleA.date - articleB.date;
+  }
+*/!*
+}
+
+// usage
+let articles = [
+  new Article("Mind", new Date(2019, 1, 1)),
+  new Article("Body", new Date(2019, 0, 1)),
+  new Article("JavaScript", new Date(2019, 11, 1))
+];
+
+*!*
+articles.sort(Article.compare);
+*/!*
+
+alert( articles[0].title ); // Body
+```
+
+Here `Article.compare` stands "over" the articles, as a means to compare them. It's not a method of an article, but rather of the whole class.
+
+Another example would be a so-called "factory" method. Imagine, we need few ways to create an article:
+
+1. Create by given parameters (`title`, `date` etc).
+2. Create an empty article with today's date.
+3. ...
+
+The first way can be implemented by the constructor. And for the second one we can make a static method of the class.
+
+Like `Article.createTodays()` here:
+
+```js run
+class Article {
+  constructor(title, date) {
+    this.title = title;
+    this.date = date;
+  }
+
+*!*
+  static createTodays() {
+    // remember, this = Article
+    return new this("Today's digest", new Date());
+  }
+*/!*
+}
+
+let article = Article.createTodays();
+
+alert( article.title ); // Todays digest
+```
+
+Now every time we need to create a today's digest, we can call `Article.createTodays()`. Once again, that's not a method of an article, but a method of the whole class.
+
+Static methods are also used in database-related classes to search/save/remove entries from the database, like this:
+
+```js
+// assuming Article is a special class for managing articles
+// static method to remove the article:
+Article.remove({id: 12345});
+```
+
+## Static properties
+
+[recent browser=Chrome]
+
+Static properties are also possible, just like regular class properties:
+
+```js run
+class Article {
+  static publisher = "Ilya Kantor";
+}
+
+alert( Article.publisher ); // Ilya Kantor
+```
+
+That is the same as a direct assignment to `Article`:
+
+```js
+Article.publisher = "Ilya Kantor";
+```
+
+## Statics and inheritance
+
+Statics are inherited, we can access `Parent.method` as `Child.method`.
+
+For instance, `Animal.compare` in the code below is inherited and accessible as `Rabbit.compare`:
+
+```js run
+class Animal {
+
+  constructor(name, speed) {
+    this.speed = speed;
+    this.name = name;
+  }
+
+  run(speed = 0) {
+    this.speed += speed;
+    alert(`${this.name} runs with speed ${this.speed}.`);
+  }
+
+*!*
+  static compare(animalA, animalB) {
+    return animalA.speed - animalB.speed;
+  }
+*/!*
+
+}
+
+// Inherit from Animal
+class Rabbit extends Animal {
+  hide() {
+    alert(`${this.name} hides!`);
+  }
+}
+
+let rabbits = [
+  new Rabbit("White Rabbit", 10),
+  new Rabbit("Black Rabbit", 5)
+];
+
+*!*
+rabbits.sort(Rabbit.compare);
+*/!*
+
+rabbits[0].run(); // Black Rabbit runs with speed 5.
+```
+
+Now we can call `Rabbit.compare` assuming that the inherited `Animal.compare` will be called.
+
+How does it work? Again, using prototypes. As you might have already guessed, extends also gives `Rabbit` the `[[Prototype]]` reference to `Animal`.
+
+
+![](animal-rabbit-static.png)
+
+So, `Rabbit` function now inherits from `Animal` function. And `Animal` function normally has `[[Prototype]]` referencing `Function.prototype`, because it doesn't `extend` anything.
+
+Here, let's check that:
+
+```js run
+class Animal {}
+class Rabbit extends Animal {}
+
+// for static properties and methods
+alert(Rabbit.__proto__ === Animal); // true
+
+// and the next step is Function.prototype
+alert(Animal.__proto__ === Function.prototype); // true
+
+// that's in addition to the "normal" prototype chain for object methods
+alert(Rabbit.prototype.__proto__ === Animal.prototype);
+```
+
+This way `Rabbit` has access to all static methods of `Animal`.
+
+## Summary
+
+Static methods are used for the functionality that doesn't relate to a concrete class instance, doesn't require an instance to exist, but rather belongs to the class as a whole, like `Article.compare` -- a generic method to compare two articles.
+
+Static properties are used when we'd like to store class-level data, also not bound to an instance.
+
+The syntax is:
+
+```js
+class MyClass {
+  static property = ...;
+
+  static method() {
+    ...
+  }
+}
+```
+
+That's technically the same as assigning to the class itself:
+
+```js
+MyClass.property = ...
+MyClass.method = ...
+```
+
+Static properties are inherited.
+
+Technically, for `class B extends A` the prototype of the class `B` itself points to `A`: `B.[[Prototype]] = A`. So if a field is not found in `B`, the search continues in `A`.
diff --git a/1-js/09-classes/04-private-protected-properties-methods/article.md b/1-js/09-classes/04-private-protected-properties-methods/article.md
new file mode 100644
index 000000000..6cd9cc5fb
--- /dev/null
+++ b/1-js/09-classes/04-private-protected-properties-methods/article.md
@@ -0,0 +1,330 @@
+
+# Private and protected properties and methods
+
+One of the most important principles of object oriented programming -- delimiting internal interface from the external one.
+
+That is "a must" practice in developing anything more complex than a "hello world" app.
+
+To understand this, let's break away from development and turn our eyes into the real world.
+
+Usually, devices that we're using are quite complex. But delimiting the internal interface from the external one allows to use them without problems.
+
+## A real-life example
+
+For instance, a coffee machine. Simple from outside: a button, a display, a few holes...And, surely, the result -- great coffee! :)
+
+![](coffee.jpg)
+
+But inside... (a picture from the repair manual)
+
+![](coffee-inside.jpg)
+
+A lot of details. But we can use it without knowing anything.
+
+Coffee machines are quite reliable, aren't they? We can use one for years, and only if something goes wrong -- bring it for repairs.
+
+The secret of reliability and simplicity of a coffee machine -- all details are well-tuned and *hidden* inside.
+
+If we remove the protective cover from the coffee machine, then using it will be much more complex (where to press?), and dangerous (it can electrocute).
+
+As we'll see, in programming objects are like coffee machines.
+
+But in order to hide inner details, we'll use not a protective cover, but rather special syntax of the language and conventions.
+
+## Internal and external interface
+
+In object-oriented programming, properties and methods are split into two groups:
+
+- *Internal interface* -- methods and properties, accessible from other methods of the class, but not from the outside.
+- *External interface* -- methods and properties, accessible also from outside the class.
+
+If we continue the analogy with the coffee machine -- what's hidden inside: a boiler tube, heating element, and so on -- is its internal interface.
+
+An internal interface is used for the object to work, its details use each other. For instance, a boiler tube is attached to the heating element.
+
+But from the outside a coffee machine is closed by the protective cover, so that no one can reach those. Details are hidden and inaccessible. We can use its features via the external interface.
+
+So, all we need to use an object is to know its external interface. We may be completely unaware how it works inside, and that's great.
+
+That was a general introduction.
+
+In JavaScript, there are three types of properties and members:
+
+- Public: accessible from anywhere. They comprise the external interface. Till now we were only using public properties and methods.
+- Private: accessible only from inside the class. These are for the internal interface.
+
+In many other languages there also exist "protected" fields: accessible only from inside the class and those extending it. They are also useful for the internal interface. They are in a sense more widespread than private ones, because we usually want inheriting classes to gain access to properly do the extension.
+
+Protected fields are not implemented in JavaScript on the language level, but in practice they are very convenient, so they are emulated.
+
+In the next step we'll make a coffee machine in JavaScript with all these types of properties. A coffee machine has a lot of details, we won't model them to stay simple (though we could).
+
+## Protecting "waterAmount"
+
+Let's make a simple coffee machine class first:
+
+```js run
+class CoffeeMachine {
+  waterAmount = 0; // the amount of water inside
+
+  constructor(power) {
+    this.power = power;
+    alert( `Created a coffee-machine, power: ${power}` );
+  }
+
+}
+
+// create the coffee machine
+let coffeeMachine = new CoffeeMachine(100);
+
+// add water
+coffeeMachine.waterAmount = 200;
+```
+
+Right now the properties `waterAmount` and `power` are public. We can easily get/set them from the outside to any value.
+
+Let's change `waterAmount` property to protected to have more control over it. For instance, we don't want anyone to set it below zero.
+
+**Protected properties are usually prefixed with an underscore `_`.**
+
+That is not enforced on the language level, but there's a convention that such properties and methods should not be accessed from the outside. Most programmers follow it.
+
+So our property will be called `_waterAmount`:
+
+```js run
+class CoffeeMachine {
+  _waterAmount = 0;
+
+  set waterAmount(value) {
+    if (value < 0) throw new Error("Negative water");
+    this._waterAmount = value;
+  }
+
+  get waterAmount() {
+    return this._waterAmount;
+  }
+
+  constructor(power) {
+    this._power = power;
+  }
+
+}
+
+// create the coffee machine
+let coffeeMachine = new CoffeeMachine(100);
+
+// add water
+coffeeMachine.waterAmount = -10; // Error: Negative water
+```
+
+Now the access is under control, so setting the water below zero fails.
+
+## Read-only "power"
+
+For `power` property, let's make it read-only. It sometimes happens that a property must be set at creation time only, and then never modified.
+
+That's exactly the case for a coffee machine: power never changes.
+
+To do so, we only need to make getter, but not the setter:
+
+```js run
+class CoffeeMachine {
+  // ...
+
+  constructor(power) {
+    this._power = power;
+  }
+
+  get power() {
+    return this._power;
+  }
+
+}
+
+// create the coffee machine
+let coffeeMachine = new CoffeeMachine(100);
+
+alert(`Power is: ${coffeeMachine.power}W`); // Power is: 100W
+
+coffeeMachine.power = 25; // Error (no setter)
+```
+
+````smart header="Getter/setter functions"
+Here we used getter/setter syntax.
+
+But most of the time `get.../set...` functions are preferred, like this:
+
+```js
+class CoffeeMachine {
+  _waterAmount = 0;
+
+  *!*setWaterAmount(value)*/!* {
+    if (value < 0) throw new Error("Negative water");
+    this._waterAmount = value;
+  }
+
+  *!*getWaterAmount()*/!* {
+    return this.waterAmount;
+  }
+}
+
+new CoffeeMachine().setWaterAmount(100);
+```
+
+That looks a bit longer, but functions are more flexible. They can accept multiple arguments (even if we don't need them right now). So, for the future, just in case we need to refactor something, functions are a safer choise.
+
+Surely, there's a tradeoff. On the other hand, get/set syntax is shorter, so ultimately there's no strict rule, it's up to you to decide.
+````
+
+```smart header="Protected fields are inherited"
+If we inherit `class MegaMachine extends CoffeeMachine`, then nothing prevents us from accessing `this._waterAmount` or `this._power` from the methods of the new class.
+
+So protected fields are naturally inheritable. Unlike private ones that we'll see below.
+```
+
+## Private "#waterLimit"
+
+[recent browser=none]
+
+There's a finished JavaScript proposal, almost in the standard, that provides language-level support for private properties and methods.
+
+Privates should start with `#`. They are only accessible from inside the class.
+
+For instance, here we add a private `#waterLimit` property and extract the water-checking logic into a separate method:
+
+```js
+class CoffeeMachine {
+*!*
+  #waterLimit = 200;
+*/!*
+
+*!*
+  #checkWater(value) {
+    if (value < 0) throw new Error("Negative water");
+    if (value > this.#waterLimit) throw new Error("Too much water");
+  }
+*/!*
+
+  _waterAmount = 0;
+
+  set waterAmount(value) {
+*!*
+    this.#checkWater(value);
+*/!*
+    this._waterAmount = value;
+  }
+
+  get waterAmount() {
+    return this.waterAmount;
+  }
+
+}
+
+let coffeeMachine = new CoffeeMachine();
+
+*!*
+coffeeMachine.#checkWater(); // Error
+coffeeMachine.#waterLimit = 1000; // Error
+*/!*
+
+coffeeMachine.waterAmount = 100; // Works
+```
+
+On the language level, `#` is a special sign that the field is private. We can't access it from outside or from inheriting classes.
+
+Private fields do not conflict with public ones. We can have both private `#waterAmount` and public `waterAmount` fields at the same time.
+
+For instance, let's make `waterAmount` an accessor for `#waterAmount`:
+
+```js run
+class CoffeeMachine {
+
+  #waterAmount = 0;
+
+  get waterAmount() {
+    return this.#waterAmount;
+  }
+
+  set waterAmount(value) {
+    if (value < 0) throw new Error("Negative water");
+    this.#waterAmount = value;
+  }
+}
+
+let machine = new CoffeeMachine();
+
+machine.waterAmount = 100;
+alert(machine.#waterAmount); // Error
+```
+
+Unlike protected ones, private fields are enforced by the language itself. That's a good thing.
+
+But if we inherit from `CoffeeMachine`, then we'll have no direct access to `#waterAmount`. We'll need to rely on `waterAmount` getter/setter:
+
+```js
+class CoffeeMachine extends CoffeeMachine() {
+  method() {
+*!*
+    alert( this.#waterAmount ); // Error: can only access from CoffeeMachine
+*/!*
+  }
+}
+```
+
+In many scenarios such limitation is too severe. If we extend a `CoffeeMachine`, we may have legitimate reason to access its internals. That's why protected fields are used most of the time, even though they are not supported by the language syntax.
+
+````warn
+Private fields are special.
+
+Remember, usually we can access fields by this[name]:
+
+```js
+class User {
+  ...
+  sayHi() {
+    let fieldName = "name";
+    alert(`Hello, ${this[fieldName]}`);
+  }
+}
+```
+
+With private fields that's impossible: `this['#name']` doesn't work. That's a syntax limitation to ensure privacy.
+````
+
+## Summary
+
+In terms of OOP, delimiting of the internal interface from the external one is called [encapsulation]("https://en.wikipedia.org/wiki/Encapsulation_(computer_programming)").
+
+It gives the following benefits:
+
+Protection for users, so that they don't shoot themselves in the feet
+: Imagine, there's a team of developers using a coffee machine. It was made by the "Best CoffeeMachine" company, and works fine, but a protective cover was removed. So the internal interface is exposed.
+
+    All developers are civilized -- they use the coffee machine as intended. But one of them, John, decided that he's the smartest one, and made some tweaks in the coffee machine internals. So the coffee machine failed two days later.
+
+    That's surely not John's fault, but rather the person who removed the protective cover and let John do his manipulations.
+
+    The same in programming. If a user of a class will change things not intended to be changed from the outside -- the consequences are unpredictable.
+
+Supportable
+: The situation in programming is more complex than with a real-life coffee machine, because we don't just buy it once. The code constantly undergoes development and improvement.
+
+    **If we strictly delimit the internal interface, then the developer of the class can freely change its internal properties and methods, even without informing the users..**
+
+    It's much easier to develop, if you know that certain methods can be renamed, their parameters can be changed, and even removed, because no external code depends on them.
+
+    For users, when a new version comes out, it may be a total overhaul, but still simple to upgrade if the external interface is the same.
+
+Hiding complexity
+: People adore to use things that are simple. At least from outside. What's inside is a different thing.
+
+    Programmers are not an exception.
+
+    **It's always convenient when implementation details are hidden, and a simple, well-documented external interface is available.**
+
+To hide internal interface we use either protected or public properties:
+
+- Protected fields start with `_`. That's a well-known convention, not enforced at the language level. Programmers should only access a field starting with `_` from its class and classes inheriting from it.
+- Private fields start with `#`. JavaScript makes sure we only can access those from inside the class.
+
+Right now, private fields are not well-supported among browsers, but can be polyfilled.
diff --git a/1-js/09-classes/04-private-protected-properties-methods/coffee-inside.jpg b/1-js/09-classes/04-private-protected-properties-methods/coffee-inside.jpg
new file mode 100644
index 000000000..60f84664d
Binary files /dev/null and b/1-js/09-classes/04-private-protected-properties-methods/coffee-inside.jpg differ
diff --git a/1-js/09-classes/04-private-protected-properties-methods/coffee.jpg b/1-js/09-classes/04-private-protected-properties-methods/coffee.jpg
new file mode 100644
index 000000000..ee26e1c06
Binary files /dev/null and b/1-js/09-classes/04-private-protected-properties-methods/coffee.jpg differ
diff --git a/1-js/09-classes/05-extend-natives/article.md b/1-js/09-classes/05-extend-natives/article.md
new file mode 100644
index 000000000..63ea96cb5
--- /dev/null
+++ b/1-js/09-classes/05-extend-natives/article.md
@@ -0,0 +1,82 @@
+
+# Extending built-in classes
+
+Built-in classes like Array, Map and others are extendable also.
+
+For instance, here `PowerArray` inherits from the native `Array`:
+
+```js run
+// add one more method to it (can do more)
+class PowerArray extends Array {
+  isEmpty() {
+    return this.length === 0;
+  }
+}
+
+let arr = new PowerArray(1, 2, 5, 10, 50);
+alert(arr.isEmpty()); // false
+
+let filteredArr = arr.filter(item => item >= 10);
+alert(filteredArr); // 10, 50
+alert(filteredArr.isEmpty()); // false
+```
+
+Please note a very interesting thing. Built-in methods like `filter`, `map` and others -- return new objects of exactly the inherited type. They rely on the `constructor` property to do so.
+
+In the example above,
+```js
+arr.constructor === PowerArray
+```
+
+So when `arr.filter()` is called, it internally creates the new array of results exactly as `new PowerArray`.
+That's actually very cool, because we can keep using `PowerArray` methods further on the result.
+
+Even more, we can customize that behavior.
+
+There's a special static getter `Symbol.species`, if exists, it returns the constructor to use in such cases.
+
+If we'd like built-in methods like `map`, `filter` will return regular arrays, we can return `Array` in `Symbol.species`, like here:
+
+```js run
+class PowerArray extends Array {
+  isEmpty() {
+    return this.length === 0;
+  }
+
+*!*
+  // built-in methods will use this as the constructor
+  static get [Symbol.species]() {
+    return Array;
+  }
+*/!*
+}
+
+let arr = new PowerArray(1, 2, 5, 10, 50);
+alert(arr.isEmpty()); // false
+
+// filter creates new array using arr.constructor[Symbol.species] as constructor
+let filteredArr = arr.filter(item => item >= 10);
+
+*!*
+// filteredArr is not PowerArray, but Array
+*/!*
+alert(filteredArr.isEmpty()); // Error: filteredArr.isEmpty is not a function
+```
+
+As you can see, now `.filter` returns `Array`. So the extended functionality is not passed any further.
+
+## No static inheritance in built-ins
+
+Built-in objects have their own static methods, for instance `Object.keys`, `Array.isArray` etc.
+
+And we've already been talking about native classes extending each other: `Array.[[Prototype]] = Object`.
+
+But statics are an exception. Built-in classes don't inherit static properties from each other.
+
+In other words, the prototype of built-in constructor `Array` does not point to `Object`. This way `Array` and `Date` do not have `Array.keys` or `Date.keys`. And that feels natural.
+
+Here's the picture structure for `Date` and `Object`:
+
+![](object-date-inheritance.png)
+
+Note, there's no link between `Date` and `Object`. Both `Object` and `Date` exist independently. `Date.prototype` inherits from `Object.prototype`, but that's all.
diff --git a/1-js/09-classes/05-extend-natives/object-date-inheritance.png b/1-js/09-classes/05-extend-natives/object-date-inheritance.png
new file mode 100644
index 000000000..73020a49e
Binary files /dev/null and b/1-js/09-classes/05-extend-natives/object-date-inheritance.png differ
diff --git a/1-js/09-classes/05-extend-natives/object-date-inheritance@2x.png b/1-js/09-classes/05-extend-natives/object-date-inheritance@2x.png
new file mode 100644
index 000000000..6520f9e26
Binary files /dev/null and b/1-js/09-classes/05-extend-natives/object-date-inheritance@2x.png differ
diff --git a/1-js/07-object-oriented-programming/11-instanceof/1-strange-instanceof/solution.md b/1-js/09-classes/06-instanceof/1-strange-instanceof/solution.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/11-instanceof/1-strange-instanceof/solution.md
rename to 1-js/09-classes/06-instanceof/1-strange-instanceof/solution.md
diff --git a/1-js/07-object-oriented-programming/11-instanceof/1-strange-instanceof/task.md b/1-js/09-classes/06-instanceof/1-strange-instanceof/task.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/11-instanceof/1-strange-instanceof/task.md
rename to 1-js/09-classes/06-instanceof/1-strange-instanceof/task.md
diff --git a/1-js/07-object-oriented-programming/11-instanceof/article.md b/1-js/09-classes/06-instanceof/article.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/11-instanceof/article.md
rename to 1-js/09-classes/06-instanceof/article.md
diff --git a/1-js/09-classes/06-instanceof/instanceof.png b/1-js/09-classes/06-instanceof/instanceof.png
new file mode 100644
index 000000000..ad0fc77ab
Binary files /dev/null and b/1-js/09-classes/06-instanceof/instanceof.png differ
diff --git a/1-js/09-classes/06-instanceof/instanceof@2x.png b/1-js/09-classes/06-instanceof/instanceof@2x.png
new file mode 100644
index 000000000..c25b166b3
Binary files /dev/null and b/1-js/09-classes/06-instanceof/instanceof@2x.png differ
diff --git a/1-js/07-object-oriented-programming/13-mixins/article.md b/1-js/09-classes/07-mixins/article.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/13-mixins/article.md
rename to 1-js/09-classes/07-mixins/article.md
diff --git a/1-js/07-object-oriented-programming/13-mixins/head.html b/1-js/09-classes/07-mixins/head.html
similarity index 100%
rename from 1-js/07-object-oriented-programming/13-mixins/head.html
rename to 1-js/09-classes/07-mixins/head.html
diff --git a/1-js/09-classes/07-mixins/mixin-inheritance.png b/1-js/09-classes/07-mixins/mixin-inheritance.png
new file mode 100644
index 000000000..6142ce7fc
Binary files /dev/null and b/1-js/09-classes/07-mixins/mixin-inheritance.png differ
diff --git a/1-js/09-classes/07-mixins/mixin-inheritance@2x.png b/1-js/09-classes/07-mixins/mixin-inheritance@2x.png
new file mode 100644
index 000000000..ccbd74300
Binary files /dev/null and b/1-js/09-classes/07-mixins/mixin-inheritance@2x.png differ
diff --git a/1-js/09-classes/index.md b/1-js/09-classes/index.md
new file mode 100644
index 000000000..87846ef6b
--- /dev/null
+++ b/1-js/09-classes/index.md
@@ -0,0 +1 @@
+# Classes
diff --git a/1-js/08-error-handling/1-try-catch/1-finally-or-code-after/solution.md b/1-js/10-error-handling/1-try-catch/1-finally-or-code-after/solution.md
similarity index 100%
rename from 1-js/08-error-handling/1-try-catch/1-finally-or-code-after/solution.md
rename to 1-js/10-error-handling/1-try-catch/1-finally-or-code-after/solution.md
diff --git a/1-js/08-error-handling/1-try-catch/1-finally-or-code-after/task.md b/1-js/10-error-handling/1-try-catch/1-finally-or-code-after/task.md
similarity index 100%
rename from 1-js/08-error-handling/1-try-catch/1-finally-or-code-after/task.md
rename to 1-js/10-error-handling/1-try-catch/1-finally-or-code-after/task.md
diff --git a/1-js/08-error-handling/1-try-catch/article.md b/1-js/10-error-handling/1-try-catch/article.md
similarity index 98%
rename from 1-js/08-error-handling/1-try-catch/article.md
rename to 1-js/10-error-handling/1-try-catch/article.md
index ac3e0031b..797293582 100644
--- a/1-js/08-error-handling/1-try-catch/article.md
+++ b/1-js/10-error-handling/1-try-catch/article.md
@@ -115,7 +115,7 @@ To catch an exception inside a scheduled function, `try..catch` must be inside t
 setTimeout(function() {
   try {    
     noSuchVariable; // try..catch handles the error!
-  } catch (e) {
+  } catch {
     alert( "error is caught here!" );
   }
 }, 1000);
@@ -165,6 +165,19 @@ try {
 }
 ```
 
+## Optional "catch" binding
+
+[recent browser=new]
+
+If we don't need error details, `catch` may omit it:
+
+```js
+try {
+  // ...
+} catch {
+  // error object omitted
+}
+```
 
 ## Using "try..catch"
 
@@ -577,7 +590,7 @@ Let's imagine we've got a fatal error outside of `try..catch`, and the script di
 
 Is there a way to react on such occurrences? We may want to log the error, show something to the user (normally they don't see error messages) etc.
 
-There is none in the specification, but environments usually provide it, because it's really useful. For instance, Node.JS has [process.on('uncaughtException')](https://nodejs.org/api/process.html#process_event_uncaughtexception) for that. And in the browser we can assign a function to special [window.onerror](mdn:api/GlobalEventHandlers/onerror) property. It will run in case of an uncaught error.
+There is none in the specification, but environments usually provide it, because it's really useful. For instance, Node.js has [process.on('uncaughtException')](https://nodejs.org/api/process.html#process_event_uncaughtexception) for that. And in the browser we can assign a function to special [window.onerror](mdn:api/GlobalEventHandlers/onerror) property. It will run in case of an uncaught error.
 
 The syntax:
 
@@ -653,6 +666,8 @@ Error objects have following properties:
 - `name` -- the string with error name (error constructor name).
 - `stack` (non-standard) -- the stack at the moment of error creation.
 
+If error is not needed, we can omit it by using `catch {` instead of `catch(err) {`.
+
 We can also generate our own errors using the `throw` operator. Technically, the argument of `throw` can be anything, but usually it's an error object inheriting from the built-in `Error` class. More on extending errors in the next chapter.
 
 Rethrowing is a basic pattern of error handling: a `catch` block usually expects and knows how to handle the particular error type, so it should rethrow errors it doesn't know.
diff --git a/1-js/10-error-handling/1-try-catch/try-catch-flow.png b/1-js/10-error-handling/1-try-catch/try-catch-flow.png
new file mode 100644
index 000000000..8b3775381
Binary files /dev/null and b/1-js/10-error-handling/1-try-catch/try-catch-flow.png differ
diff --git a/1-js/10-error-handling/1-try-catch/try-catch-flow@2x.png b/1-js/10-error-handling/1-try-catch/try-catch-flow@2x.png
new file mode 100644
index 000000000..f85eb6321
Binary files /dev/null and b/1-js/10-error-handling/1-try-catch/try-catch-flow@2x.png differ
diff --git a/1-js/08-error-handling/2-custom-errors/1-format-error/solution.md b/1-js/10-error-handling/2-custom-errors/1-format-error/solution.md
similarity index 100%
rename from 1-js/08-error-handling/2-custom-errors/1-format-error/solution.md
rename to 1-js/10-error-handling/2-custom-errors/1-format-error/solution.md
diff --git a/1-js/08-error-handling/2-custom-errors/1-format-error/task.md b/1-js/10-error-handling/2-custom-errors/1-format-error/task.md
similarity index 100%
rename from 1-js/08-error-handling/2-custom-errors/1-format-error/task.md
rename to 1-js/10-error-handling/2-custom-errors/1-format-error/task.md
diff --git a/1-js/08-error-handling/2-custom-errors/article.md b/1-js/10-error-handling/2-custom-errors/article.md
similarity index 96%
rename from 1-js/08-error-handling/2-custom-errors/article.md
rename to 1-js/10-error-handling/2-custom-errors/article.md
index d7d61166d..5079c746d 100644
--- a/1-js/08-error-handling/2-custom-errors/article.md
+++ b/1-js/10-error-handling/2-custom-errors/article.md
@@ -19,7 +19,7 @@ let json = `{ "name": "John", "age": 30 }`;
 
 Internally, we'll use `JSON.parse`. If it receives malformed `json`, then it throws `SyntaxError`.
 
-But even if `json` is syntactically correct, that doesn't mean that it's a valid user, right? It may miss the necessary data. For instance, if may not have `name` and `age` properties that are essential for our users.
+But even if `json` is syntactically correct, that doesn't mean that it's a valid user, right? It may miss the necessary data. For instance, it may not have `name` and `age` properties that are essential for our users.
 
 Our function `readUser(json)` will not only read JSON, but check ("validate") the data. If there are no required fields, or the format is wrong, then that's an error. And that's not a `SyntaxError`, because the data is syntactically correct, but another kind of error. We'll call it `ValidationError` and create a class for it. An error of that kind should also carry the information about the offending field.
 
@@ -185,7 +185,7 @@ try {
 
 The new class `PropertyRequiredError` is easy to use: we only need to pass the property name: `new PropertyRequiredError(property)`. The human-readable `message` is generated by the constructor.
 
-Please note that `this.name` in `PropertyRequiredError` constructor is again assigned manually. That may become a bit tedius -- to assign `this.name = <class name>` when creating each custom error. But there's a way out. We can make our own "basic error" class that removes this burden from our shoulders by using `this.constructor.name` for `this.name` in the constructor. And then inherit from it.
+Please note that `this.name` in `PropertyRequiredError` constructor is again assigned manually. That may become a bit tedious -- to assign `this.name = <class name>` when creating each custom error. But there's a way out. We can make our own "basic error" class that removes this burden from our shoulders by using `this.constructor.name` for `this.name` in the constructor. And then inherit from it.
 
 Let's call it `MyError`.
 
diff --git a/1-js/08-error-handling/index.md b/1-js/10-error-handling/index.md
similarity index 100%
rename from 1-js/08-error-handling/index.md
rename to 1-js/10-error-handling/index.md
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/solution.md b/1-js/11-async/01-callbacks/01-animate-circle-callback/solution.md
similarity index 100%
rename from 1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/solution.md
rename to 1-js/11-async/01-callbacks/01-animate-circle-callback/solution.md
diff --git a/6-async/01-callbacks/01-animate-circle-callback/solution.view/index.html b/1-js/11-async/01-callbacks/01-animate-circle-callback/solution.view/index.html
similarity index 100%
rename from 6-async/01-callbacks/01-animate-circle-callback/solution.view/index.html
rename to 1-js/11-async/01-callbacks/01-animate-circle-callback/solution.view/index.html
diff --git a/6-async/01-callbacks/01-animate-circle-callback/task.md b/1-js/11-async/01-callbacks/01-animate-circle-callback/task.md
similarity index 100%
rename from 6-async/01-callbacks/01-animate-circle-callback/task.md
rename to 1-js/11-async/01-callbacks/01-animate-circle-callback/task.md
diff --git a/6-async/01-callbacks/article.md b/1-js/11-async/01-callbacks/article.md
similarity index 94%
rename from 6-async/01-callbacks/article.md
rename to 1-js/11-async/01-callbacks/article.md
index a5a91793e..ee0bb3caa 100644
--- a/6-async/01-callbacks/article.md
+++ b/1-js/11-async/01-callbacks/article.md
@@ -98,7 +98,7 @@ Here we did it in `loadScript`, but of course, it's a general approach.
 
 ## Callback in callback
 
-How to load two scripts sequentially: the first one, and then the second one after it?
+How can we load two scripts sequentially: the first one, and then the second one after it?
 
 The natural solution would be to put the second `loadScript` call inside the callback, like this:
 
@@ -140,7 +140,7 @@ So, every new action is inside a callback. That's fine for few actions, but not
 
 ## Handling errors
 
-In examples above we didn't consider errors. What if the script loading fails? Our callback should be able to react on that.
+In the above examples we didn't consider errors. What if the script loading fails? Our callback should be able to react on that.
 
 Here's an improved version of `loadScript` that tracks loading errors:
 
@@ -262,7 +262,7 @@ function step3(error, script) {
 
 See? It does the same, and there's no deep nesting now because we made every action a separate top-level function.
 
-It works, but the code looks like a torn apart spreadsheet. It's difficult to read, and you probably noticed that. One needs to eye-jump between pieces while reading it. That's inconvenient, especially if the reader is not familiar with the code and doesn't know where to eye-jump.
+It works, but the code looks like a torn apart spreadsheet. It's difficult to read, and you probably noticed that one needs to eye-jump between pieces while reading it. That's inconvenient, especially if the reader is not familiar with the code and doesn't know where to eye-jump.
 
 Also, the functions named `step*` are all of single use, they are created only to avoid the "pyramid of doom." No one is going to reuse them outside of the action chain. So there's a bit of a namespace cluttering here.
 
diff --git a/1-js/11-async/01-callbacks/callback-hell.png b/1-js/11-async/01-callbacks/callback-hell.png
new file mode 100644
index 000000000..567ec284e
Binary files /dev/null and b/1-js/11-async/01-callbacks/callback-hell.png differ
diff --git a/1-js/11-async/01-callbacks/callback-hell@2x.png b/1-js/11-async/01-callbacks/callback-hell@2x.png
new file mode 100644
index 000000000..4d6b0ad70
Binary files /dev/null and b/1-js/11-async/01-callbacks/callback-hell@2x.png differ
diff --git a/6-async/01-callbacks/one.js b/1-js/11-async/01-callbacks/one.js
similarity index 100%
rename from 6-async/01-callbacks/one.js
rename to 1-js/11-async/01-callbacks/one.js
diff --git a/6-async/02-promise-basics/01-re-resolve/solution.md b/1-js/11-async/02-promise-basics/01-re-resolve/solution.md
similarity index 100%
rename from 6-async/02-promise-basics/01-re-resolve/solution.md
rename to 1-js/11-async/02-promise-basics/01-re-resolve/solution.md
diff --git a/6-async/02-promise-basics/01-re-resolve/task.md b/1-js/11-async/02-promise-basics/01-re-resolve/task.md
similarity index 100%
rename from 6-async/02-promise-basics/01-re-resolve/task.md
rename to 1-js/11-async/02-promise-basics/01-re-resolve/task.md
diff --git a/6-async/02-promise-basics/02-delay-promise/solution.md b/1-js/11-async/02-promise-basics/02-delay-promise/solution.md
similarity index 100%
rename from 6-async/02-promise-basics/02-delay-promise/solution.md
rename to 1-js/11-async/02-promise-basics/02-delay-promise/solution.md
diff --git a/6-async/02-promise-basics/02-delay-promise/task.md b/1-js/11-async/02-promise-basics/02-delay-promise/task.md
similarity index 100%
rename from 6-async/02-promise-basics/02-delay-promise/task.md
rename to 1-js/11-async/02-promise-basics/02-delay-promise/task.md
diff --git a/3-animation/2-css-animations/3-animate-circle/solution.md b/1-js/11-async/02-promise-basics/03-animate-circle-promise/solution.md
similarity index 100%
rename from 3-animation/2-css-animations/3-animate-circle/solution.md
rename to 1-js/11-async/02-promise-basics/03-animate-circle-promise/solution.md
diff --git a/6-async/02-promise-basics/03-animate-circle-promise/solution.view/index.html b/1-js/11-async/02-promise-basics/03-animate-circle-promise/solution.view/index.html
similarity index 100%
rename from 6-async/02-promise-basics/03-animate-circle-promise/solution.view/index.html
rename to 1-js/11-async/02-promise-basics/03-animate-circle-promise/solution.view/index.html
diff --git a/6-async/02-promise-basics/03-animate-circle-promise/task.md b/1-js/11-async/02-promise-basics/03-animate-circle-promise/task.md
similarity index 100%
rename from 6-async/02-promise-basics/03-animate-circle-promise/task.md
rename to 1-js/11-async/02-promise-basics/03-animate-circle-promise/task.md
diff --git a/6-async/02-promise-basics/article.md b/1-js/11-async/02-promise-basics/article.md
similarity index 70%
rename from 6-async/02-promise-basics/article.md
rename to 1-js/11-async/02-promise-basics/article.md
index 6f0ebe704..c4bb84eb1 100644
--- a/6-async/02-promise-basics/article.md
+++ b/1-js/11-async/02-promise-basics/article.md
@@ -48,8 +48,8 @@ Here's an example of a Promise constructor and a simple executor function with i
 let promise = new Promise(function(resolve, reject) {
   // the function is executed automatically when the promise is constructed
 
-  // after 1 second signal that the job is done with the result "done!"
-  setTimeout(() => *!*resolve("done!")*/!*, 1000);
+  // after 1 second signal that the job is done with the result "done"
+  setTimeout(() => *!*resolve("done")*/!*, 1000);
 });
 ```
 
@@ -80,7 +80,7 @@ To summarize, the executor should do a job (something that takes time usually) a
 The Promise that is either resolved or rejected is called "settled", as opposed to a "pending" Promise.
 
 ````smart header="There can be only a single result or an error"
-The executor should call only one `resolve` or `reject`. The promise's state change is final.
+The executor should call only one `resolve` or one `reject`. The promise's state change is final.
 
 All further calls of `resolve` and `reject` are ignored:
 
@@ -95,11 +95,11 @@ let promise = new Promise(function(resolve, reject) {
 
 The idea is that a job done by the executor may have only one result or an error.
 
-Further, `resolve`/`reject` expect only one argument and will ignore additional arguments.
+Also, `resolve`/`reject` expect only one argument (or none) and will ignore additional arguments.
 ````
 
 ```smart header="Reject with `Error` objects"
-In case if something goes wrong, we can call `reject` with any type of argument (just like `resolve`). But it is recommended to use `Error` objects (or objects that inherit from `Error`). The reasoning for that will soon become apparent.
+In case something goes wrong, we can call `reject` with any type of argument (just like `resolve`). But it is recommended to use `Error` objects (or objects that inherit from `Error`). The reasoning for that will soon become apparent.
 ```
 
 ````smart header="Immediately calling `resolve`/`reject`"
@@ -118,14 +118,18 @@ That's fine. We immediately have a resolved Promise, nothing wrong with that.
 ````
 
 ```smart header="The `state` and `result` are internal"
-The properties `state` and `result` of the Promise object are internal. We can't directly access them from our "consuming code". We can use the methods `.then`/`.catch` for that. They are described below.
+The properties `state` and `result` of the Promise object are internal. We can't directly access them from our "consuming code". We can use the methods `.then`/`.catch`/`.finally` for that. They are described below.
 ```
 
-## Consumers: "then" and "catch"
+## Consumers: then, catch, finally
 
-A Promise object serves as a link between the executor (the "producing code" or "singer") and the consuming functions (the "fans"), which will receive the result or error. Consuming functions can be registered (subscribed) using the methods `.then` and `.catch`.
+A Promise object serves as a link between the executor (the "producing code" or "singer") and the consuming functions (the "fans"), which will receive the result or error. Consuming functions can be registered (subscribed) using methods `.then`, `.catch` and `.finally`.
 
-The syntax of `.then` is:
+### then
+
+The most important, fundamental one is `.then`.
+
+The syntax is:
 
 ```js
 promise.then(
@@ -144,7 +148,7 @@ The second argument of `.then` is a function that:
 1. runs when the Promise is rejected, and
 2. receives the error.
 
-For instance, here's the reaction to a successfuly resolved promise:
+For instance, here's a reaction to a successfuly resolved promise:
 
 ```js run
 let promise = new Promise(function(resolve, reject) {
@@ -190,6 +194,8 @@ promise.then(alert); // shows "done!" after 1 second
 */!*
 ```
 
+### catch
+
 If we're interested only in errors, then we can use `null` as the first argument: `.then(null, errorHandlingFunction)`. Or we can use `.catch(errorHandlingFunction)`, which is exactly the same:
 
 
@@ -206,45 +212,68 @@ promise.catch(alert); // shows "Error: Whoops!" after 1 second
 
 The call `.catch(f)` is a complete analog of `.then(null, f)`, it's just a shorthand.
 
-````smart header="On settled promises `then` runs immediately"
-If a promise is pending, `.then/catch` handlers wait for the result. Otherwise, if a promise has already settled, they execute immediately:
+### finally
 
-```js run
-// an immediately resolved promise
-let promise = new Promise(resolve => resolve("done!"));
+Just like there's a `finally` clause in a regular `try {...} catch {...}`, there's `finally` in promises.
 
-promise.then(alert); // done! (shows up right now)
+The call `.finally(f)` is similar to `.then(f, f)` in the sense that it always runs when the promise is settled: be it resolve or reject.
+
+`finally` is a good handler for performing cleanup, e.g. stopping our loading indicators, as they are not needed any more, no matter what the outcome is.
+
+Like this:
+
+```js
+new Promise((resolve, reject) => {
+  /* do something that takes time, and then call resolve/reject */
+})
+*!*
+  // runs when the promise is settled, doesn't matter successfully or not
+  .finally(() => stop loading indicator)
+*/!*
+  .then(result => show result, err => show error)
 ```
 
-Some tasks may sometimes require time and sometimes finish immediately. The good thing is: the `.then` handler is guaranteed to run in both cases.
-````
+It's not exactly an alias though. There are several important differences:
 
-````smart header="Handlers of `.then`/`.catch` are always asynchronous"
-Even when the Promise is immediately resolved, code which occurs on lines *below* your `.then`/`.catch` may still execute first.
+1. A `finally` handler has no arguments. In `finally` we don't know whether the promise is successful or not. That's all right, as our task is usually to perform "general" finalizing procedures.
+2. Finally passes through results and errors to the next handler.
 
-The JavaScript engine has an internal execution queue which gets all `.then/catch` handlers.
+    For instance, here the result is passed through `finally` to `then`:
+    ```js run
+    new Promise((resolve, reject) => {
+      setTimeout(() => resolve("result"), 2000)
+    })
+      .finally(() => alert("Promise ready"))
+      .then(result => alert(result)); // <-- .then handles the result
+    ```
 
-But it only looks into that queue when the current execution is finished.
+    And here there's an error in the promise, passed through `finally` to `catch`:
 
-In other words, `.then/catch` handlers are pending execution until the engine is done with the current code.
+    ```js run
+    new Promise((resolve, reject) => {
+      throw new Error("error");
+    })
+      .finally(() => alert("Promise ready"))
+      .catch(err => alert(err));  // <-- .catch handles the error object
+    ```  
 
-For instance, here:
+    That's very convenient, because finally is not meant to process promise results. So it passes them through.
 
-```js run
-// an "immediately" resolved Promise
-const executor = resolve => resolve("done!");
-const promise = new Promise(executor);
+    We'll talk more about promise chaining and result-passing between handlers in the next chapter.
 
-promise.then(alert); // this alert shows last (*)
+3. Last, but not least, `.finally(f)` is a more convenient syntax than `.then(f, f)`: no need to duplicate the function.
 
-alert("code finished"); // this alert shows first
-```
+````smart header="On settled promises handlers runs immediately"
+If a promise is pending, `.then/catch/finally` handlers wait for the result. Otherwise, if a promise has already settled, they execute immediately:
 
-The promise becomes settled immediately, but the engine first finishes the current code, calls `alert`, and only *afterwards* looks into the queue to run `.then` handler.
+```js run
+// an immediately resolved promise
+let promise = new Promise(resolve => resolve("done!"));
 
-So the code *after* `.then` ends up always running *before* the Promise's subscribers, even in the case of an immediately-resolved Promise.
+promise.then(alert); // done! (shows up right now)
+```
 
-Usually that's unimportant, but in some scenarios the order may matter a great deal.
+The good thing is: a `.then` handler is guaranteed to run whether the promise takes time or settles it immediately.
 ````
 
 Next, let's see more practical examples of how promises can help us to write asynchronous code.
@@ -288,7 +317,7 @@ function loadScript(src) {
 Usage:
 
 ```js run
-let promise = loadScript("https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.2.0/lodash.js");
+let promise = loadScript("https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js");
 
 promise.then(
   script => alert(`${script.src} is loaded!`),
@@ -300,11 +329,10 @@ promise.then(script => alert('One more handler to do something else!'));
 
 We can immediately see a few benefits over the callback-based pattern:
 
-```compare minus="Callbacks" plus="Promises"
-- We must have a ready `callback` function when calling `loadScript`. In other words, we must know what to do with the result *before* `loadScript` is called.
-- There can be only one callback.
-+ Promises allow us to do things in the natural order. First, we run `loadScript`, and `.then` we write what to do with the result.
-+ We can call `.then` on a Promise as many times as we want. Each time, we're adding a new "fan", a new subscribing function, to the "subscription list". More about this in the next section: [Promise Chaining](/promise-chaining).
-```
 
-So Promises already give us better code flow and flexibility. But there's more. We'll see that in the next chapters.
+| Promises | Callbacks |
+|----------|-----------|
+| Promises allow us to do things in the natural order. First, we run `loadScript(script)`, and `.then` we write what to do with the result. | We must have a `callback` function at our disposal when calling `loadScript(script, callback)`. In other words, we must know what to do with the result *before* `loadScript` is called. |
+| We can call `.then` on a Promise as many times as we want. Each time, we're adding a new "fan", a new subscribing function, to the "subscription list". More about this in the next chapter: [](info:promise-chaining). | There can be only one callback. |
+
+So Promises give us better code flow and flexibility. But there's more. We'll see that in the next chapters.
diff --git a/6-async/02-promise-basics/head.html b/1-js/11-async/02-promise-basics/head.html
similarity index 100%
rename from 6-async/02-promise-basics/head.html
rename to 1-js/11-async/02-promise-basics/head.html
diff --git a/6-async/02-promise-basics/promise-init.png b/1-js/11-async/02-promise-basics/promise-init.png
similarity index 100%
rename from 6-async/02-promise-basics/promise-init.png
rename to 1-js/11-async/02-promise-basics/promise-init.png
diff --git a/6-async/02-promise-basics/promise-init@2x.png b/1-js/11-async/02-promise-basics/promise-init@2x.png
similarity index 100%
rename from 6-async/02-promise-basics/promise-init@2x.png
rename to 1-js/11-async/02-promise-basics/promise-init@2x.png
diff --git a/1-js/11-async/02-promise-basics/promise-reject-1.png b/1-js/11-async/02-promise-basics/promise-reject-1.png
new file mode 100644
index 000000000..3ae74879c
Binary files /dev/null and b/1-js/11-async/02-promise-basics/promise-reject-1.png differ
diff --git a/1-js/11-async/02-promise-basics/promise-reject-1@2x.png b/1-js/11-async/02-promise-basics/promise-reject-1@2x.png
new file mode 100644
index 000000000..9eff3793c
Binary files /dev/null and b/1-js/11-async/02-promise-basics/promise-reject-1@2x.png differ
diff --git a/1-js/11-async/02-promise-basics/promise-resolve-1.png b/1-js/11-async/02-promise-basics/promise-resolve-1.png
new file mode 100644
index 000000000..b4bb51826
Binary files /dev/null and b/1-js/11-async/02-promise-basics/promise-resolve-1.png differ
diff --git a/1-js/11-async/02-promise-basics/promise-resolve-1@2x.png b/1-js/11-async/02-promise-basics/promise-resolve-1@2x.png
new file mode 100644
index 000000000..ecb4af35d
Binary files /dev/null and b/1-js/11-async/02-promise-basics/promise-resolve-1@2x.png differ
diff --git a/1-js/11-async/02-promise-basics/promise-resolve-reject.png b/1-js/11-async/02-promise-basics/promise-resolve-reject.png
new file mode 100644
index 000000000..6f0294f01
Binary files /dev/null and b/1-js/11-async/02-promise-basics/promise-resolve-reject.png differ
diff --git a/1-js/11-async/02-promise-basics/promise-resolve-reject@2x.png b/1-js/11-async/02-promise-basics/promise-resolve-reject@2x.png
new file mode 100644
index 000000000..b59301ff7
Binary files /dev/null and b/1-js/11-async/02-promise-basics/promise-resolve-reject@2x.png differ
diff --git a/6-async/03-promise-chaining/01-then-vs-catch/solution.md b/1-js/11-async/03-promise-chaining/01-then-vs-catch/solution.md
similarity index 100%
rename from 6-async/03-promise-chaining/01-then-vs-catch/solution.md
rename to 1-js/11-async/03-promise-chaining/01-then-vs-catch/solution.md
diff --git a/6-async/03-promise-chaining/01-then-vs-catch/task.md b/1-js/11-async/03-promise-chaining/01-then-vs-catch/task.md
similarity index 96%
rename from 6-async/03-promise-chaining/01-then-vs-catch/task.md
rename to 1-js/11-async/03-promise-chaining/01-then-vs-catch/task.md
index 51c08d7c9..cefca60aa 100644
--- a/6-async/03-promise-chaining/01-then-vs-catch/task.md
+++ b/1-js/11-async/03-promise-chaining/01-then-vs-catch/task.md
@@ -3,10 +3,11 @@
 Are these code fragments equal? In other words, do they behave the same way in any circumstances, for any handler functions?
 
 ```js
-promise.then(f1, f2);
+promise.then(f1).catch(f2);
 ```
 
-Versus;
+Versus:
+
 ```js
-promise.then(f1).catch(f2);
+promise.then(f1, f2);
 ```
diff --git a/1-js/11-async/03-promise-chaining/article.md b/1-js/11-async/03-promise-chaining/article.md
new file mode 100644
index 000000000..62e05bdd6
--- /dev/null
+++ b/1-js/11-async/03-promise-chaining/article.md
@@ -0,0 +1,387 @@
+
+# Promises chaining
+
+Let's return to the problem mentioned in the chapter <info:callbacks>: we have a sequence of asynchronous tasks to be done one after another. For instance, loading scripts. How can we code it well?
+
+Promises provide a couple of recipes to do that.
+
+In this chapter we cover promise chaining.
+
+It looks like this:
+
+```js run
+new Promise(function(resolve, reject) {
+
+  setTimeout(() => resolve(1), 1000); // (*)
+
+}).then(function(result) { // (**)
+
+  alert(result); // 1
+  return result * 2;
+
+}).then(function(result) { // (***)
+
+  alert(result); // 2
+  return result * 2;
+
+}).then(function(result) {
+
+  alert(result); // 4
+  return result * 2;
+
+});
+```
+
+The idea is that the result is passed through the chain of `.then` handlers.
+
+Here the flow is:
+1. The initial promise resolves in 1 second `(*)`,
+2. Then the `.then` handler is called `(**)`.
+3. The value that it returns is passed to the next `.then` handler `(***)`
+4. ...and so on.
+
+As the result is passed along the chain of handlers, we can see a sequence of `alert` calls: `1` -> `2` -> `4`.
+
+![](promise-then-chain.png)
+
+The whole thing works, because a call to `promise.then` returns a promise, so that we can call the next `.then` on it.
+
+When a handler returns a value, it becomes the result of that promise, so the next `.then` is called with it.
+
+To make these words more clear, here's the start of the chain:
+
+```js run
+new Promise(function(resolve, reject) {
+
+  setTimeout(() => resolve(1), 1000);
+
+}).then(function(result) {
+
+  alert(result);
+  return result * 2; // <-- (1)
+
+}) // <-- (2)
+// .then…
+```
+
+The value returned by `.then` is a promise, that's why we are able to add another `.then` at `(2)`. When the value is returned in `(1)`, that promise becomes resolved, so the next handler runs with the value.
+
+**A classic newbie error: technically we can also add many `.then` to a single promise. This is not chaining.**
+
+For example:
+```js run
+let promise = new Promise(function(resolve, reject) {
+  setTimeout(() => resolve(1), 1000);
+});
+
+promise.then(function(result) {
+  alert(result); // 1
+  return result * 2;
+});
+
+promise.then(function(result) {
+  alert(result); // 1
+  return result * 2;
+});
+
+promise.then(function(result) {
+  alert(result); // 1
+  return result * 2;
+});
+```
+
+What we did here is just several handlers to one promise. They don't pass the result to each other, instead they process it independently.
+
+Here's the picture (compare it with the chaining above):
+
+![](promise-then-many.png)
+
+All `.then` on the same promise get the same result -- the result of that promise. So in the code above all `alert` show the same: `1`.
+
+In practice we rarely need multiple handlers for one promise. Chaining is used much more often.
+
+## Returning promises
+
+Normally, a value returned by a `.then` handler is immediately passed to the next handler. But there's an exception.
+
+If the returned value is a promise, then the further execution is suspended until it settles. After that, the result of that promise is given to the next `.then` handler.
+
+For instance:
+
+```js run
+new Promise(function(resolve, reject) {
+
+  setTimeout(() => resolve(1), 1000);
+
+}).then(function(result) {
+
+  alert(result); // 1
+
+*!*
+  return new Promise((resolve, reject) => { // (*)
+    setTimeout(() => resolve(result * 2), 1000);
+  });
+*/!*
+
+}).then(function(result) { // (**)
+
+  alert(result); // 2
+
+  return new Promise((resolve, reject) => {
+    setTimeout(() => resolve(result * 2), 1000);
+  });
+
+}).then(function(result) {
+
+  alert(result); // 4
+
+});
+```
+
+Here the first `.then` shows `1` returns `new Promise(…)` in the line `(*)`. After one second it resolves, and the result (the argument of `resolve`, here it's `result*2`) is passed on to handler of the second `.then` in the line `(**)`. It shows `2` and does the same thing.
+
+So the output is again 1 -> 2 -> 4, but now with 1 second delay between `alert` calls.
+
+Returning promises allows us to build chains of asynchronous actions.
+
+## Example: loadScript
+
+Let's use this feature with `loadScript` to load scripts one by one, in sequence:
+
+```js run
+loadScript("/article/promise-chaining/one.js")
+  .then(function(script) {
+    return loadScript("/article/promise-chaining/two.js");
+  })
+  .then(function(script) {
+    return loadScript("/article/promise-chaining/three.js");
+  })
+  .then(function(script) {
+    // use functions declared in scripts
+    // to show that they indeed loaded
+    one();
+    two();
+    three();
+  });
+```
+
+This code can be made bit shorter with arrow functions:
+
+```js run
+loadScript("/article/promise-chaining/one.js")
+  .then(script => loadScript("/article/promise-chaining/two.js"))
+  .then(script => loadScript("/article/promise-chaining/three.js"))
+  .then(script => {
+    // scripts are loaded, we can use functions declared there
+    one();
+    two();
+    three();
+  });
+```
+
+
+Here each `loadScript` call returns a promise, and the next `.then` runs when it resolves. Then it initiates the loading of the next script. So scripts are loaded one after another.
+
+We can add more asynchronous actions to the chain. Please note that code is still "flat", it grows down, not to the right. There are no signs of "pyramid of doom".
+
+Please note that technically we can add `.then` directly to each `loadScript`, like this:
+
+```js run
+loadScript("/article/promise-chaining/one.js").then(script1 => {
+  loadScript("/article/promise-chaining/two.js").then(script2 => {
+    loadScript("/article/promise-chaining/three.js").then(script3 => {
+      // this function has access to variables script1, script2 and script3
+      one();
+      two();
+      three();
+    });
+  });
+});
+```
+
+This code does the same: loads 3 scripts in sequence. But it "grows to the right". So we have the same problem as with callbacks.
+
+People who start to use promises sometimes don't know about chaining, so they write it this way. Generally, chaining is preferred.
+
+Sometimes it's ok to write `.then` directly, because the nested function has access to the outer scope. In the example above the most nested callback has access to all variables `script1`, `script2`, `script3`. But that's an exception rather than a rule.
+
+
+````smart header="Thenables"
+To be precise, `.then` may return an arbitrary "thenable" object, and it will be treated the same way as a promise.
+
+A "thenable" object is any object with a method `.then`.
+
+The idea is that 3rd-party libraries may implement "promise-compatible" objects of their own. They can have extended set of methods, but also be compatible with native promises, because they implement `.then`.
+
+Here's an example of a thenable object:
+
+```js run
+class Thenable {
+  constructor(num) {
+    this.num = num;
+  }
+  then(resolve, reject) {
+    alert(resolve); // function() { native code }
+    // resolve with this.num*2 after the 1 second
+    setTimeout(() => resolve(this.num * 2), 1000); // (**)
+  }
+}
+
+new Promise(resolve => resolve(1))
+  .then(result => {
+    return new Thenable(result); // (*)
+  })
+  .then(alert); // shows 2 after 1000ms
+```
+
+JavaScript checks the object returned by `.then` handler in the line `(*)`: if it has a callable method named `then`, then it calls that method providing native functions `resolve`, `reject` as arguments (similar to executor) and waits until one of them is called. In the example above `resolve(2)` is called after 1 second `(**)`. Then the result is passed further down the chain.
+
+This feature allows to integrate custom objects with promise chains without having to inherit from `Promise`.
+````
+
+
+## Bigger example: fetch
+
+In frontend programming promises are often used for network requests. So let's see an extended example of that.
+
+We'll use the [fetch](mdn:api/WindowOrWorkerGlobalScope/fetch) method to load the information about the user from the remote server. The method is quite complex, it has many optional parameters, but the basic usage is quite simple:
+
+```js
+let promise = fetch(url);
+```
+
+This makes a network request to the `url` and returns a promise. The promise resolves with a `response` object when the remote server responds with headers, but *before the full response is downloaded*.
+
+To read the full response, we should call a method `response.text()`: it returns a promise that resolves  when the full text downloaded from the remote server, with that text as a result.
+
+The code below makes a request to `user.json` and loads its text from the server:
+
+```js run
+fetch('/article/promise-chaining/user.json')
+  // .then below runs when the remote server responds
+  .then(function(response) {
+    // response.text() returns a new promise that resolves with the full response text
+    // when we finish downloading it
+    return response.text();
+  })
+  .then(function(text) {
+    // ...and here's the content of the remote file
+    alert(text); // {"name": "iliakan", isAdmin: true}
+  });
+```
+
+There is also a method `response.json()` that reads the remote data and parses it as JSON. In our case that's even more convenient, so let's switch to it.
+
+We'll also use arrow functions for brevity:
+
+```js run
+// same as above, but response.json() parses the remote content as JSON
+fetch('/article/promise-chaining/user.json')
+  .then(response => response.json())
+  .then(user => alert(user.name)); // iliakan
+```
+
+Now let's do something with the loaded user.
+
+For instance, we can make one more request to github, load the user profile and show the avatar:
+
+```js run
+// Make a request for user.json
+fetch('/article/promise-chaining/user.json')
+  // Load it as json
+  .then(response => response.json())
+  // Make a request to github
+  .then(user => fetch(`https://api.github.com/users/${user.name}`))
+  // Load the response as json
+  .then(response => response.json())
+  // Show the avatar image (githubUser.avatar_url) for 3 seconds (maybe animate it)
+  .then(githubUser => {
+    let img = document.createElement('img');
+    img.src = githubUser.avatar_url;
+    img.className = "promise-avatar-example";
+    document.body.append(img);
+
+    setTimeout(() => img.remove(), 3000); // (*)
+  });
+```
+
+The code works, see comments about the details, but it should be quite self-descriptive. Although, there's a potential problem in it, a typical error of those who begin to use promises.
+
+Look at the line `(*)`: how can we do something *after* the avatar has finished showing and gets removed? For instance, we'd like to show a form for editing that user or something else. As of now, there's no way.
+
+To make the chain extendable, we need to return a promise that resolves when the avatar finishes showing.
+
+Like this:
+
+```js run
+fetch('/article/promise-chaining/user.json')
+  .then(response => response.json())
+  .then(user => fetch(`https://api.github.com/users/${user.name}`))
+  .then(response => response.json())
+*!*
+  .then(githubUser => new Promise(function(resolve, reject) {
+*/!*
+    let img = document.createElement('img');
+    img.src = githubUser.avatar_url;
+    img.className = "promise-avatar-example";
+    document.body.append(img);
+
+    setTimeout(() => {
+      img.remove();
+*!*
+      resolve(githubUser);
+*/!*
+    }, 3000);
+  }))
+  // triggers after 3 seconds
+  .then(githubUser => alert(`Finished showing ${githubUser.name}`));
+```
+
+Now right after `setTimeout` runs `img.remove()`, it calls `resolve(githubUser)`, thus passing the control to the next `.then` in the chain and passing forward the user data.
+
+As a rule, an asynchronous action should always return a promise.
+
+That makes it possible to plan actions after it. Even if we don't plan to extend the chain now, we may need it later.
+
+Finally, we can split the code into reusable functions:
+
+```js run
+function loadJson(url) {
+  return fetch(url)
+    .then(response => response.json());
+}
+
+function loadGithubUser(name) {
+  return fetch(`https://api.github.com/users/${name}`)
+    .then(response => response.json());
+}
+
+function showAvatar(githubUser) {
+  return new Promise(function(resolve, reject) {
+    let img = document.createElement('img');
+    img.src = githubUser.avatar_url;
+    img.className = "promise-avatar-example";
+    document.body.append(img);
+
+    setTimeout(() => {
+      img.remove();
+      resolve(githubUser);
+    }, 3000);
+  });
+}
+
+// Use them:
+loadJson('/article/promise-chaining/user.json')
+  .then(user => loadGithubUser(user.name))
+  .then(showAvatar)
+  .then(githubUser => alert(`Finished showing ${githubUser.name}`));
+  // ...
+```
+
+## Summary
+
+If a `.then` (or `catch/finally`, doesn't matter) handler returns a promise, the rest of the chain waits until it settles. When it does, its result (or error) is passed further.
+
+Here's a full picture:
+
+![](promise-handler-variants.png)
diff --git a/6-async/03-promise-chaining/getMessage.js b/1-js/11-async/03-promise-chaining/getMessage.js
similarity index 100%
rename from 6-async/03-promise-chaining/getMessage.js
rename to 1-js/11-async/03-promise-chaining/getMessage.js
diff --git a/6-async/03-promise-chaining/head.html b/1-js/11-async/03-promise-chaining/head.html
similarity index 100%
rename from 6-async/03-promise-chaining/head.html
rename to 1-js/11-async/03-promise-chaining/head.html
diff --git a/6-async/03-promise-chaining/one.js b/1-js/11-async/03-promise-chaining/one.js
similarity index 100%
rename from 6-async/03-promise-chaining/one.js
rename to 1-js/11-async/03-promise-chaining/one.js
diff --git a/1-js/11-async/03-promise-chaining/promise-handler-variants-2.png b/1-js/11-async/03-promise-chaining/promise-handler-variants-2.png
new file mode 100644
index 000000000..712f57b82
Binary files /dev/null and b/1-js/11-async/03-promise-chaining/promise-handler-variants-2.png differ
diff --git a/1-js/11-async/03-promise-chaining/promise-handler-variants-2@2x.png b/1-js/11-async/03-promise-chaining/promise-handler-variants-2@2x.png
new file mode 100644
index 000000000..5b57be809
Binary files /dev/null and b/1-js/11-async/03-promise-chaining/promise-handler-variants-2@2x.png differ
diff --git a/1-js/11-async/03-promise-chaining/promise-handler-variants.png b/1-js/11-async/03-promise-chaining/promise-handler-variants.png
new file mode 100644
index 000000000..2643fde89
Binary files /dev/null and b/1-js/11-async/03-promise-chaining/promise-handler-variants.png differ
diff --git a/1-js/11-async/03-promise-chaining/promise-handler-variants@2x.png b/1-js/11-async/03-promise-chaining/promise-handler-variants@2x.png
new file mode 100644
index 000000000..313e241cc
Binary files /dev/null and b/1-js/11-async/03-promise-chaining/promise-handler-variants@2x.png differ
diff --git a/1-js/11-async/03-promise-chaining/promise-then-chain.png b/1-js/11-async/03-promise-chaining/promise-then-chain.png
new file mode 100644
index 000000000..fab8a92ad
Binary files /dev/null and b/1-js/11-async/03-promise-chaining/promise-then-chain.png differ
diff --git a/1-js/11-async/03-promise-chaining/promise-then-chain@2x.png b/1-js/11-async/03-promise-chaining/promise-then-chain@2x.png
new file mode 100644
index 000000000..421b59359
Binary files /dev/null and b/1-js/11-async/03-promise-chaining/promise-then-chain@2x.png differ
diff --git a/1-js/11-async/03-promise-chaining/promise-then-many.png b/1-js/11-async/03-promise-chaining/promise-then-many.png
new file mode 100644
index 000000000..b13d20a9e
Binary files /dev/null and b/1-js/11-async/03-promise-chaining/promise-then-many.png differ
diff --git a/1-js/11-async/03-promise-chaining/promise-then-many@2x.png b/1-js/11-async/03-promise-chaining/promise-then-many@2x.png
new file mode 100644
index 000000000..f0609c946
Binary files /dev/null and b/1-js/11-async/03-promise-chaining/promise-then-many@2x.png differ
diff --git a/6-async/03-promise-chaining/three.js b/1-js/11-async/03-promise-chaining/three.js
similarity index 100%
rename from 6-async/03-promise-chaining/three.js
rename to 1-js/11-async/03-promise-chaining/three.js
diff --git a/6-async/03-promise-chaining/two.js b/1-js/11-async/03-promise-chaining/two.js
similarity index 100%
rename from 6-async/03-promise-chaining/two.js
rename to 1-js/11-async/03-promise-chaining/two.js
diff --git a/6-async/03-promise-chaining/user.json b/1-js/11-async/03-promise-chaining/user.json
similarity index 100%
rename from 6-async/03-promise-chaining/user.json
rename to 1-js/11-async/03-promise-chaining/user.json
diff --git a/6-async/03-promise-chaining/02-error-async/solution.md b/1-js/11-async/04-promise-error-handling/01-error-async/solution.md
similarity index 100%
rename from 6-async/03-promise-chaining/02-error-async/solution.md
rename to 1-js/11-async/04-promise-error-handling/01-error-async/solution.md
diff --git a/6-async/03-promise-chaining/02-error-async/task.md b/1-js/11-async/04-promise-error-handling/01-error-async/task.md
similarity index 100%
rename from 6-async/03-promise-chaining/02-error-async/task.md
rename to 1-js/11-async/04-promise-error-handling/01-error-async/task.md
diff --git a/1-js/11-async/04-promise-error-handling/article.md b/1-js/11-async/04-promise-error-handling/article.md
new file mode 100644
index 000000000..ca67202aa
--- /dev/null
+++ b/1-js/11-async/04-promise-error-handling/article.md
@@ -0,0 +1,343 @@
+
+# Error handling with promises
+
+Asynchronous actions may sometimes fail: in case of an error the corresponding promise becomes rejected. For instance, `fetch` fails if the remote server is not available. We can use `.catch` to handle errors (rejections).
+
+Promise chaining is great at that aspect. When a promise rejects, the control jumps to the closest rejection handler down the chain. That's very convenient in practice.
+
+For instance, in the code below the URL is wrong (no such server) and `.catch` handles the error:
+
+```js run
+*!*
+fetch('https://no-such-server.blabla') // rejects
+*/!*
+  .then(response => response.json())
+  .catch(err => alert(err)) // TypeError: failed to fetch (the text may vary)
+```
+
+Or, maybe, everything is all right with the server, but the response is not valid JSON:
+
+```js run
+fetch('/') // fetch works fine now, the server responds successfully
+*!*
+  .then(response => response.json()) // rejects: the page is HTML, not a valid json
+*/!*
+  .catch(err => alert(err)) // SyntaxError: Unexpected token < in JSON at position 0
+```
+
+The easiest way to catch all errors is to append `.catch` to the end of chain:
+
+```js run
+fetch('/article/promise-chaining/user.json')
+  .then(response => response.json())
+  .then(user => fetch(`https://api.github.com/users/${user.name}`))
+  .then(response => response.json())
+  .then(githubUser => new Promise((resolve, reject) => {
+    let img = document.createElement('img');
+    img.src = githubUser.avatar_url;
+    img.className = "promise-avatar-example";
+    document.body.append(img);
+
+    setTimeout(() => {
+      img.remove();
+      resolve(githubUser);
+    }, 3000);
+  }))
+*!*
+  .catch(error => alert(error.message));
+*/!*
+```
+
+Normally, `.catch` doesn't trigger at all, because there are no errors. But if any of the promises above rejects (a network problem or invalid json or whatever), then it would catch it.
+
+## Implicit try..catch
+
+The code of a promise executor and promise handlers has an "invisible `try..catch`" around it. If an error happens, it gets caught and treated as a rejection.
+
+For instance, this code:
+
+```js run
+new Promise((resolve, reject) => {
+*!*
+  throw new Error("Whoops!");
+*/!*
+}).catch(alert); // Error: Whoops!
+```
+
+...Works exactly the same as this:
+
+```js run
+new Promise((resolve, reject) => {
+*!*
+  reject(new Error("Whoops!"));
+*/!*  
+}).catch(alert); // Error: Whoops!
+```
+
+The "invisible `try..catch`" around the executor automatically catches the error and treats it as a rejection.
+
+This happens not only in the executor, but in its handlers as well. If we `throw` inside a `.then` handler, that means a rejected promise, so the control jumps to the nearest error handler.
+
+Here's an example:
+
+```js run
+new Promise((resolve, reject) => {
+  resolve("ok");
+}).then((result) => {
+*!*
+  throw new Error("Whoops!"); // rejects the promise
+*/!*
+}).catch(alert); // Error: Whoops!
+```
+
+This happens for all errors, not just those caused by the `throw` statement. For example, a programming error:
+
+```js run
+new Promise((resolve, reject) => {
+  resolve("ok");
+}).then((result) => {
+*!*
+  blabla(); // no such function
+*/!*
+}).catch(alert); // ReferenceError: blabla is not defined
+```
+
+The final `.catch` not only catches explicit rejections, but also occasional errors in the handlers above.
+
+## Rethrowing
+
+As we already noticed, `.catch` behaves like `try..catch`. We may have as many `.then` handlers as we want, and then use a single `.catch` at the end to handle errors in all of them.
+
+In a regular `try..catch` we can analyze the error and maybe rethrow it if can't handle. The same thing is possible for promises.
+
+If we `throw` inside `.catch`, then the control goes to the next closest error handler. And if we handle the error and finish normally, then it continues to the closest successful `.then` handler.
+
+In the example below the `.catch` successfully handles the error:
+
+```js run
+// the execution: catch -> then
+new Promise((resolve, reject) => {
+
+  throw new Error("Whoops!");
+
+}).catch(function(error) { 
+
+  alert("The error is handled, continue normally");
+
+}).then(() => alert("Next successful handler runs"));
+```
+
+Here the `.catch` block finishes normally. So the next successful `.then` handler is called.
+
+In the example below we see the other situation with `.catch`. The handler `(*)` catches the error and just can't handle it (e.g. it only knows how to handle `URIError`), so it throws it again:
+
+```js run
+// the execution: catch -> catch -> then
+new Promise((resolve, reject) => {
+
+  throw new Error("Whoops!");
+
+}).catch(function(error) { // (*)
+
+  if (error instanceof URIError) {
+    // handle it
+  } else {
+    alert("Can't handle such error");
+
+*!*
+    throw error; // throwing this or another error jumps to the next catch
+*/!*
+  }
+
+}).then(function() {
+  /* never runs here */
+}).catch(error => { // (**)
+
+  alert(`The unknown error has occurred: ${error}`);
+  // don't return anything => execution goes the normal way
+
+});
+```
+
+Then the execution jumps from the first `.catch` `(*)` to the next one `(**)` down the chain.
+
+In the section below we'll see a practical example of rethrowing.
+
+## Fetch error handling example
+
+Let's improve error handling for the user-loading example.
+
+The promise returned by [fetch](mdn:api/WindowOrWorkerGlobalScope/fetch) rejects when it's impossible to make a request. For instance, a remote server is not available, or the URL is malformed. But if the remote server responds with error 404, or even error 500, then it's considered a valid response.
+
+What if the server returns a non-JSON page with error 500 in the line `(*)`? What if there's no such user, and github returns a page with error 404 at `(**)`?
+
+```js run
+fetch('no-such-user.json') // (*)
+  .then(response => response.json())
+  .then(user => fetch(`https://api.github.com/users/${user.name}`)) // (**)
+  .then(response => response.json())
+  .catch(alert); // SyntaxError: Unexpected token < in JSON at position 0
+  // ...
+```
+
+
+As of now, the code tries to load the response as JSON no matter what and dies with a syntax error. You can see that by running the example above, as the file `no-such-user.json` doesn't exist.
+
+That's not good, because the error just falls through the chain, without details: what failed and where.
+
+So let's add one more step: we should check the `response.status` property that has HTTP status, and if it's not 200, then throw an error.
+
+```js run
+class HttpError extends Error { // (1)
+  constructor(response) {
+    super(`${response.status} for ${response.url}`);
+    this.name = 'HttpError';
+    this.response = response;
+  }
+}
+
+function loadJson(url) { // (2)
+  return fetch(url)
+    .then(response => {
+      if (response.status == 200) {
+        return response.json();
+      } else {
+        throw new HttpError(response);
+      }
+    })
+}
+
+loadJson('no-such-user.json') // (3)
+  .catch(alert); // HttpError: 404 for .../no-such-user.json
+```
+
+1. We make a custom class for HTTP Errors to distinguish them from other types of errors. Besides, the new class has a constructor that accepts `response` object and saves it in the error. So error-handling code will be able to access it.
+2. Then we put together the requesting and error-handling code into a function that fetches the `url` *and* treats any non-200 status as an error. That's convenient, because we often need such logic.
+3. Now `alert` shows a more helpful descriptive message.
+
+The great thing about having our own class for errors is that we can easily check for it in error-handling code.
+
+For instance, we can make a request, and then if we get 404 -- ask the user to modify the information.
+
+The code below loads a user with the given name from github. If there's no such user, then it asks for the correct name:
+
+```js run
+function demoGithubUser() {
+  let name = prompt("Enter a name?", "iliakan");
+
+  return loadJson(`https://api.github.com/users/${name}`)
+    .then(user => {
+      alert(`Full name: ${user.name}.`);
+      return user;
+    })
+    .catch(err => {
+*!*
+      if (err instanceof HttpError && err.response.status == 404) {
+*/!*
+        alert("No such user, please reenter.");
+        return demoGithubUser();
+      } else {
+        throw err; // (*)
+      }
+    });
+}
+
+demoGithubUser();
+```
+
+Please note: `.catch` here catches all errors, but it "knows how to handle" only `HttpError 404`. In that particular case it means that there's no such user, and `.catch` just retries in that case.
+
+For other errors, it has no idea what could go wrong. Maybe a programming error or something. So it just rethrows it in the line `(*)`.
+
+## Unhandled rejections
+
+What happens when an error is not handled? For instance, after the rethrow `(*)` in the example above.
+
+Or we could just forget to append an error handler to the end of the chain, like here:
+
+```js untrusted run refresh
+new Promise(function() {
+  noSuchFunction(); // Error here (no such function)
+})
+  .then(() => {
+    // zero or many promise handlers
+  }); // without .catch at the end!
+```
+
+In case of an error, the promise state becomes "rejected", and the execution should jump to the closest rejection handler. But there is no such handler in the examples above. So the error gets "stuck".
+
+In practice, just like with a regular unhandled errors, it means that something has terribly gone wrong, the script probably died.
+
+Most JavaScript engines track such situations and generate a global error in that case. We can see it in the console.
+
+In the browser we can catch such errors using the event `unhandledrejection`:
+
+```js run
+*!*
+window.addEventListener('unhandledrejection', function(event) {
+  // the event object has two special properties:
+  alert(event.promise); // [object Promise] - the promise that generated the error
+  alert(event.reason); // Error: Whoops! - the unhandled error object
+});
+*/!*
+
+new Promise(function() {
+  throw new Error("Whoops!");
+}); // no catch to handle the error
+```
+
+The event is the part of the [HTML standard](https://html.spec.whatwg.org/multipage/webappapis.html#unhandled-promise-rejections).
+
+If an error occurs, and there's no `.catch`, the `unhandledrejection` handler triggers, and gets the `event` object with the information about the error, so we can do something.
+
+Usually such errors are unrecoverable, so our best way out is to inform the user about the problem and probably report the incident to the server.
+
+In non-browser environments like Node.js there are other similar ways to track unhandled errors.
+
+
+## Summary
+
+- `.catch` handles promise rejections of all kinds: be it a `reject()` call, or an error thrown in a handler.
+- We should place `.catch` exactly in places where we want to handle errors and know how to handle them. The handler should analyze errors (custom error classes help) and rethrow unknown ones.
+- It's normal not to use `.catch` if we don't know how to handle errors (all errors are unrecoverable).
+- In any case we should have the `unhandledrejection` event handler (for browsers, and analogs for other environments), to track unhandled errors and inform the user (and probably our server) about the them, so that our app never "just dies".
+
+And finally, if we have load-indication, then `.finally` is a great handler to stop it when the fetch is complete:
+
+```js run
+function demoGithubUser() {
+  let name = prompt("Enter a name?", "iliakan");
+
+*!*
+  document.body.style.opacity = 0.3; // (1) start the indication
+*/!*
+
+  return loadJson(`https://api.github.com/users/${name}`)
+*!*
+    .finally(() => { // (2) stop the indication
+      document.body.style.opacity = '';
+      return new Promise(resolve => setTimeout(resolve, 0)); // (*)
+    })
+*/!*
+    .then(user => {
+      alert(`Full name: ${user.name}.`);
+      return user;
+    })
+    .catch(err => {
+      if (err instanceof HttpError && err.response.status == 404) {
+        alert("No such user, please reenter.");
+        return demoGithubUser();
+      } else {
+        throw err;
+      }
+    });
+}
+
+demoGithubUser();
+```
+
+Here on the line `(1)` we indicate loading by dimming the document. The method doesn't matter, could use any type of indication instead.
+
+When the promise is settled, be it a successful fetch or an error, `finally` triggers at the line `(2)` and stops the indication.
+
+There's a little browser trick `(*)` with returning a zero-timeout promise from `finally`. That's because some browsers (like Chrome) need "a bit time" outside promise handlers to paint document changes. So it ensures that the indication is visually stopped before going further on the chain.
diff --git a/1-js/11-async/04-promise-error-handling/getMessage.js b/1-js/11-async/04-promise-error-handling/getMessage.js
new file mode 100644
index 000000000..6c5893433
--- /dev/null
+++ b/1-js/11-async/04-promise-error-handling/getMessage.js
@@ -0,0 +1,3 @@
+function getMessage() {
+  return "Hello, world!";
+}
diff --git a/1-js/11-async/04-promise-error-handling/head.html b/1-js/11-async/04-promise-error-handling/head.html
new file mode 100644
index 000000000..31c6b4271
--- /dev/null
+++ b/1-js/11-async/04-promise-error-handling/head.html
@@ -0,0 +1,41 @@
+<script>
+function loadScript(src) {
+  return new Promise(function(resolve, reject) {
+    let script = document.createElement('script');
+    script.src = src;
+
+    script.onload = () => resolve(script);
+    script.onerror = () => reject(new Error("Script load error: " + src));
+
+    document.head.append(script);
+  });
+}
+
+class HttpError extends Error {
+  constructor(response) {
+    super(`${response.status} for ${response.url}`);
+    this.name = 'HttpError';
+    this.response = response;
+  }
+}
+
+function loadJson(url) {
+  return fetch(url)
+    .then(response => {
+      if (response.status == 200) {
+        return response.json();
+      } else {
+        throw new HttpError(response);
+      }
+    })
+}
+</script>
+
+<style>
+.promise-avatar-example {
+  border-radius: 50%;
+  position: fixed;
+  left: 10px;
+  top: 10px;
+}
+</style>
diff --git a/6-async/04-promise-api/one.js b/1-js/11-async/04-promise-error-handling/one.js
similarity index 100%
rename from 6-async/04-promise-api/one.js
rename to 1-js/11-async/04-promise-error-handling/one.js
diff --git a/1-js/11-async/04-promise-error-handling/promise-handler-variants-2.png b/1-js/11-async/04-promise-error-handling/promise-handler-variants-2.png
new file mode 100644
index 000000000..712f57b82
Binary files /dev/null and b/1-js/11-async/04-promise-error-handling/promise-handler-variants-2.png differ
diff --git a/1-js/11-async/04-promise-error-handling/promise-handler-variants-2@2x.png b/1-js/11-async/04-promise-error-handling/promise-handler-variants-2@2x.png
new file mode 100644
index 000000000..5b57be809
Binary files /dev/null and b/1-js/11-async/04-promise-error-handling/promise-handler-variants-2@2x.png differ
diff --git a/1-js/11-async/04-promise-error-handling/promise-handler-variants.png b/1-js/11-async/04-promise-error-handling/promise-handler-variants.png
new file mode 100644
index 000000000..2643fde89
Binary files /dev/null and b/1-js/11-async/04-promise-error-handling/promise-handler-variants.png differ
diff --git a/1-js/11-async/04-promise-error-handling/promise-handler-variants@2x.png b/1-js/11-async/04-promise-error-handling/promise-handler-variants@2x.png
new file mode 100644
index 000000000..313e241cc
Binary files /dev/null and b/1-js/11-async/04-promise-error-handling/promise-handler-variants@2x.png differ
diff --git a/1-js/11-async/04-promise-error-handling/promise-then-chain.png b/1-js/11-async/04-promise-error-handling/promise-then-chain.png
new file mode 100644
index 000000000..fab8a92ad
Binary files /dev/null and b/1-js/11-async/04-promise-error-handling/promise-then-chain.png differ
diff --git a/1-js/11-async/04-promise-error-handling/promise-then-chain@2x.png b/1-js/11-async/04-promise-error-handling/promise-then-chain@2x.png
new file mode 100644
index 000000000..421b59359
Binary files /dev/null and b/1-js/11-async/04-promise-error-handling/promise-then-chain@2x.png differ
diff --git a/1-js/11-async/04-promise-error-handling/promise-then-many.png b/1-js/11-async/04-promise-error-handling/promise-then-many.png
new file mode 100644
index 000000000..b13d20a9e
Binary files /dev/null and b/1-js/11-async/04-promise-error-handling/promise-then-many.png differ
diff --git a/1-js/11-async/04-promise-error-handling/promise-then-many@2x.png b/1-js/11-async/04-promise-error-handling/promise-then-many@2x.png
new file mode 100644
index 000000000..f0609c946
Binary files /dev/null and b/1-js/11-async/04-promise-error-handling/promise-then-many@2x.png differ
diff --git a/1-js/11-async/04-promise-error-handling/three.js b/1-js/11-async/04-promise-error-handling/three.js
new file mode 100644
index 000000000..8536e85a1
--- /dev/null
+++ b/1-js/11-async/04-promise-error-handling/three.js
@@ -0,0 +1,3 @@
+function three() {
+  alert(3);
+}
diff --git a/6-async/04-promise-api/two.js b/1-js/11-async/04-promise-error-handling/two.js
similarity index 100%
rename from 6-async/04-promise-api/two.js
rename to 1-js/11-async/04-promise-error-handling/two.js
diff --git a/6-async/04-promise-api/iliakan.json b/1-js/11-async/04-promise-error-handling/user.json
similarity index 100%
rename from 6-async/04-promise-api/iliakan.json
rename to 1-js/11-async/04-promise-error-handling/user.json
diff --git a/6-async/04-promise-api/01-promise-errors-as-results/solution.md b/1-js/11-async/05-promise-api/01-promise-errors-as-results/solution.md
similarity index 100%
rename from 6-async/04-promise-api/01-promise-errors-as-results/solution.md
rename to 1-js/11-async/05-promise-api/01-promise-errors-as-results/solution.md
diff --git a/6-async/04-promise-api/01-promise-errors-as-results/solution.view/index.html b/1-js/11-async/05-promise-api/01-promise-errors-as-results/solution.view/index.html
similarity index 100%
rename from 6-async/04-promise-api/01-promise-errors-as-results/solution.view/index.html
rename to 1-js/11-async/05-promise-api/01-promise-errors-as-results/solution.view/index.html
diff --git a/6-async/04-promise-api/01-promise-errors-as-results/source.view/index.html b/1-js/11-async/05-promise-api/01-promise-errors-as-results/source.view/index.html
similarity index 100%
rename from 6-async/04-promise-api/01-promise-errors-as-results/source.view/index.html
rename to 1-js/11-async/05-promise-api/01-promise-errors-as-results/source.view/index.html
diff --git a/6-async/04-promise-api/01-promise-errors-as-results/task.md b/1-js/11-async/05-promise-api/01-promise-errors-as-results/task.md
similarity index 90%
rename from 6-async/04-promise-api/01-promise-errors-as-results/task.md
rename to 1-js/11-async/05-promise-api/01-promise-errors-as-results/task.md
index d6904f1bd..c37ad56e3 100644
--- a/6-async/04-promise-api/01-promise-errors-as-results/task.md
+++ b/1-js/11-async/05-promise-api/01-promise-errors-as-results/task.md
@@ -20,13 +20,13 @@ Promise.all(urls.map(url => fetch(url)))
   });
 ```
 
-The problem is that if any of requests fails, then `Promise.all` rejects with the error, and we loose results of all the other requests.
+The problem is that if any of requests fails, then `Promise.all` rejects with the error, and we lose the results of all the other requests.
 
 That's not good.
 
 Modify the code so that the array `responses` in the line `(*)` would include the response objects for successful fetches and error objects for failed ones.
 
-For instance, if one of URLs is bad, then it should be like:
+For instance, if one of the URLs is bad, then it should be like:
 
 ```js
 let urls = [
diff --git a/6-async/01-callbacks/01-animate-circle-callback/solution.md b/1-js/11-async/05-promise-api/02-promise-errors-as-results-2/solution.md
similarity index 100%
rename from 6-async/01-callbacks/01-animate-circle-callback/solution.md
rename to 1-js/11-async/05-promise-api/02-promise-errors-as-results-2/solution.md
diff --git a/6-async/04-promise-api/02-promise-errors-as-results-2/solution.view/index.html b/1-js/11-async/05-promise-api/02-promise-errors-as-results-2/solution.view/index.html
similarity index 100%
rename from 6-async/04-promise-api/02-promise-errors-as-results-2/solution.view/index.html
rename to 1-js/11-async/05-promise-api/02-promise-errors-as-results-2/solution.view/index.html
diff --git a/6-async/04-promise-api/02-promise-errors-as-results-2/source.view/index.html b/1-js/11-async/05-promise-api/02-promise-errors-as-results-2/source.view/index.html
similarity index 100%
rename from 6-async/04-promise-api/02-promise-errors-as-results-2/source.view/index.html
rename to 1-js/11-async/05-promise-api/02-promise-errors-as-results-2/source.view/index.html
diff --git a/6-async/04-promise-api/02-promise-errors-as-results-2/task.md b/1-js/11-async/05-promise-api/02-promise-errors-as-results-2/task.md
similarity index 85%
rename from 6-async/04-promise-api/02-promise-errors-as-results-2/task.md
rename to 1-js/11-async/05-promise-api/02-promise-errors-as-results-2/task.md
index ec28728b0..d28cf87e7 100644
--- a/6-async/04-promise-api/02-promise-errors-as-results-2/task.md
+++ b/1-js/11-async/05-promise-api/02-promise-errors-as-results-2/task.md
@@ -1,6 +1,6 @@
 # Fault-tolerant fetch with JSON
 
-Improve the solution of the previous task <info:task/promise-errors-as-results>. Now we need not just to call `fetch`, but to load the JSON objects from given URLs.
+Improve the solution of the previous task <info:task/promise-errors-as-results>. Now we need not just to call `fetch`, but to load the JSON objects from the given URLs.
 
 Here's the example code to do that:
 
@@ -25,7 +25,7 @@ Promise.all(urls.map(url => fetch(url)))
   });
 ```
 
-The problem is that if any of requests fails, then `Promise.all` rejects with the error, and we loose results of all the other requests. So the code above is not fault-tolerant, just like the one in the previous task.
+The problem is that if any of requests fails, then `Promise.all` rejects with the error, and we lose results of all the other requests. So the code above is not fault-tolerant, just like the one in the previous task.
 
 Modify the code so that the array in the line `(*)` would include parsed JSON for successful requests and error for errored ones.
 
diff --git a/6-async/04-promise-api/article.md b/1-js/11-async/05-promise-api/article.md
similarity index 80%
rename from 6-async/04-promise-api/article.md
rename to 1-js/11-async/05-promise-api/article.md
index e0e5eda47..d049f3b09 100644
--- a/6-async/04-promise-api/article.md
+++ b/1-js/11-async/05-promise-api/article.md
@@ -35,13 +35,13 @@ function loadCached(url) {
   return fetch(url)
     .then(response => response.text())
     .then(text => {
-      cache.set(url,text); 
+      cache.set(url,text);
       return text;
     });
 }
 ```
 
-We can use `loadCached(url).then(…)`, because the function is guaranteed to return a promise. That's the purpose `Promise.resolve` in the line `(*)`: it makes sure the interface unified. We can always use `.then` after `loadCached`.
+We can use `loadCached(url).then(…)`, because the function is guaranteed to return a promise. That's the purpose `Promise.resolve` serves in the line `(*)`: it makes sure the interface is unified. We can always use `.then` after `loadCached`.
 
 ## Promise.reject
 
@@ -63,23 +63,29 @@ We cover it here for completeness, rarely used in real code.
 
 ## Promise.all
 
-The method to run many promises in parallel and wait till all of them are ready.
+Let's say we want to run many promises to execute in parallel, and wait till all of them are ready.
+
+For instance, download several URLs in parallel and process the content when all are done.
+
+That's what `Promise.all` is for.
 
 The syntax is:
 
 ```js
-let promise = Promise.all(iterable);
+let promise = Promise.all([...promises...]);
 ```
 
-It takes an `iterable` object with promises, technically it can be any iterable, but usually it's an array, and returns a new promise. The new promise resolves with when all of them are settled and has an array of their results.
+It takes an array of promises (technically can be any iterable, but usually an array) and returns a new promise.
+
+The new promise resolves when all listed promises are settled and has an array of their results.
 
 For instance, the `Promise.all` below settles after 3 seconds, and then its result is an array `[1, 2, 3]`:
 
 ```js run
 Promise.all([
-  new Promise((resolve, reject) => setTimeout(() => resolve(1), 3000)), // 1
-  new Promise((resolve, reject) => setTimeout(() => resolve(2), 2000)), // 2
-  new Promise((resolve, reject) => setTimeout(() => resolve(3), 1000))  // 3
+  new Promise(resolve => setTimeout(() => resolve(1), 3000)), // 1
+  new Promise(resolve => setTimeout(() => resolve(2), 2000)), // 2
+  new Promise(resolve => setTimeout(() => resolve(3), 1000))  // 3
 ]).then(alert); // 1,2,3 when promises are ready: each promise contributes an array member
 ```
 
@@ -132,7 +138,6 @@ If any of the promises is rejected, `Promise.all` immediately rejects with that
 
 For instance:
 
-
 ```js run
 Promise.all([
   new Promise((resolve, reject) => setTimeout(() => resolve(1), 1000)),
@@ -145,12 +150,12 @@ Promise.all([
 
 Here the second promise rejects in two seconds. That leads to immediate rejection of `Promise.all`, so `.catch` executes: the rejection error becomes the outcome of the whole `Promise.all`.
 
-The important detail is that promises provide no way to "cancel" or "abort" their execution. So other promises continue to execute, and the eventually settle, but all their results are ignored.
+The important detail is that promises provide no way to "cancel" or "abort" their execution. So other promises continue to execute, and then eventually settle, but all their results are ignored.
 
 There are ways to avoid this: we can either write additional code to `clearTimeout` (or otherwise cancel) the promises in case of an error, or we can make errors show up as members in the resulting array (see the task below this chapter about it).
 
-````smart header="`Promise.all(iterable)` allows non-promise items in `iterable`"
-Normally, `Promise.all(iterable)` accepts an iterable (in most cases an array) of promises. But if any of those objects is not a promise, it's wrapped in `Promise.resolve`.
+````smart header="`Promise.all(...)` allows non-promise items in `iterable`"
+Normally, `Promise.all(...)` accepts an iterable (in most cases an array) of promises. But if any of those objects is not a promise, it's wrapped in `Promise.resolve`.
 
 For instance, here the results are `[1, 2, 3]`:
 
@@ -170,7 +175,7 @@ So we are able to pass non-promise values to `Promise.all` where convenient.
 
 ## Promise.race
 
-Similar to `Promise.all` takes an iterable of promises, but instead of waiting for all of them to finish -- waits for the first result (or error), and goes on with it.
+Similar to `Promise.all`, it takes an iterable of promises, but instead of waiting for all of them to finish, it waits for the first result (or error), and goes on with it.
 
 The syntax is:
 
@@ -194,8 +199,8 @@ So, the first result/error becomes the result of the whole `Promise.race`. After
 
 There are 4 static methods of `Promise` class:
 
-1. `Promise.resolve(value)` -- makes a resolved promise with the given value,
-2. `Promise.reject(error)` -- makes a rejected promise with the given error,
+1. `Promise.resolve(value)` -- makes a resolved promise with the given value.
+2. `Promise.reject(error)` -- makes a rejected promise with the given error.
 3. `Promise.all(promises)` -- waits for all promises to resolve and returns an array of their results. If any of the given promises rejects, then it becomes the error of `Promise.all`, and all other results are ignored.
 4. `Promise.race(promises)` -- waits for the first promise to settle, and its result/error becomes the outcome.
 
diff --git a/6-async/04-promise-api/head.html b/1-js/11-async/05-promise-api/head.html
similarity index 100%
rename from 6-async/04-promise-api/head.html
rename to 1-js/11-async/05-promise-api/head.html
diff --git a/1-js/11-async/05-promise-api/iliakan.json b/1-js/11-async/05-promise-api/iliakan.json
new file mode 100644
index 000000000..32f89971a
--- /dev/null
+++ b/1-js/11-async/05-promise-api/iliakan.json
@@ -0,0 +1,4 @@
+{
+  "name": "iliakan",
+  "isAdmin": true
+}
diff --git a/1-js/11-async/05-promise-api/one.js b/1-js/11-async/05-promise-api/one.js
new file mode 100644
index 000000000..948a60e07
--- /dev/null
+++ b/1-js/11-async/05-promise-api/one.js
@@ -0,0 +1,3 @@
+function one() {
+  alert(1);
+}
diff --git a/1-js/11-async/05-promise-api/two.js b/1-js/11-async/05-promise-api/two.js
new file mode 100644
index 000000000..b04795b86
--- /dev/null
+++ b/1-js/11-async/05-promise-api/two.js
@@ -0,0 +1,3 @@
+function two() {
+  alert(2);
+}
diff --git a/1-js/11-async/06-promisify/article.md b/1-js/11-async/06-promisify/article.md
new file mode 100644
index 000000000..e72329ce1
--- /dev/null
+++ b/1-js/11-async/06-promisify/article.md
@@ -0,0 +1,118 @@
+# Promisification
+
+Promisification -- is a long word for a simple transform. It's conversion of a function that accepts a callback into a function returning a promise.
+
+In other words, we create a wrapper-function that does the same, internally calling the original one, but returns a promise.
+
+Such transforms are often needed in real-life, as many functions and libraries are callback-based. But promises are more convenient. So it makes sense to promisify those.
+
+For instance, we have `loadScript(src, callback)` from the chapter <info:callbacks>.
+
+```js run
+function loadScript(src, callback) {
+  let script = document.createElement('script');
+  script.src = src;
+
+  script.onload = () => callback(null, script);
+  script.onerror = () => callback(new Error(`Script load error for ${src}`));
+
+  document.head.append(script);
+}
+
+// usage:
+// loadScript('path/script.js', (err, script) => {...})
+```
+
+Let's promisify it. The new `loadScriptPromise(src)` function will do the same, but accept only `src` (no callback) and return a promise.
+
+```js
+let loadScriptPromise = function(src) {
+  return new Promise((resolve, reject) => {
+    loadScript(src, (err, script) => {
+      if (err) reject(err)
+      else resolve(script);
+    });
+  })
+}
+
+// usage:
+// loadScriptPromise('path/script.js').then(...)
+```
+
+Now `loadScriptPromise` fits well in our promise-based code.
+
+As we can see, it delegates all the work to the original `loadScript`, providing its own callback that translates to promise `resolve/reject`.
+
+As we may need to promisify many functions, it makes sense to use a helper.
+
+That's actually very simple -- `promisify(f)` below takes a to-promisify function `f` and returns a wrapper function.
+
+That wrapper does the same as in the code above: returns a promise and passes the call to the original `f`, tracking the result in a custom callback:
+
+```js
+function promisify(f) {
+  return function (...args) { // return a wrapper-function
+    return new Promise((resolve, reject) => {
+      function callback(err, result) { // our custom callback for f
+        if (err) {
+          return reject(err);
+        } else {
+          resolve(result);
+        }
+      }
+
+      args.push(callback); // append our custom callback to the end of arguments
+
+      f.call(this, ...args); // call the original function
+    });
+  };
+};
+
+// usage:
+let loadScriptPromise = promisify(loadScript);
+loadScriptPromise(...).then(...);
+```
+
+Here we assume that the original function expects a callback with two arguments `(err, result)`. That's what we encounter most often. Then our custom callback is in exactly the right format, and `promisify` works great for such a case.
+
+But what if the original `f` expects a callback with more arguments `callback(err, res1, res2)`?
+
+Here's a modification of `promisify` that returns an array of multiple callback results:
+
+```js
+// promisify(f, true) to get array of results
+function promisify(f, manyArgs = false) {
+  return function (...args) {
+    return new Promise((resolve, reject) => {
+      function *!*callback(err, ...results*/!*) { // our custom callback for f
+        if (err) {
+          return reject(err);
+        } else {
+          // resolve with all callback results if manyArgs is specified
+          *!*resolve(manyArgs ? results : results[0]);*/!*
+        }
+      }
+
+      args.push(callback);
+
+      f.call(this, ...args);
+    });
+  };
+};
+
+// usage:
+f = promisify(f, true);
+f(...).then(arrayOfResults => ..., err => ...)
+```
+
+In some cases, `err` may be absent at all: `callback(result)`, or there's something exotic in the callback format, then we can promisify such functions manually.
+
+There are also modules with a bit more flexible promisification functions, e.g. [es6-promisify](https://github.com/digitaldesignlabs/es6-promisify). In Node.js, there's a built-in `util.promisify` function for that.
+
+```smart
+Promisification is a great approach, especially when you use `async/await` (see the next chapter), but not a total replacement for callbacks.
+
+Remember, a promise may have only one result, but a callback may technically be called many times.
+
+So promisification is only meant for functions that call the callback once. Further calls will be ignored.
+```
diff --git a/1-js/11-async/07-microtask-queue/article.md b/1-js/11-async/07-microtask-queue/article.md
new file mode 100644
index 000000000..993042e57
--- /dev/null
+++ b/1-js/11-async/07-microtask-queue/article.md
@@ -0,0 +1,190 @@
+
+# Microtasks and event loop
+
+Promise handlers `.then`/`.catch`/`.finally` are always asynchronous.
+
+Even when a Promise is immediately resolved, the code on the lines *below* your `.then`/`.catch`/`.finally` will still execute first.
+
+Here's the code that demonstrates it:
+
+```js run
+let promise = Promise.resolve();
+
+promise.then(() => alert("promise done"));
+
+alert("code finished"); // this alert shows first
+```
+
+If you run it, you see `code finished` first, and then `promise done`.
+
+That's strange, because the promise is definitely done from the beginning.
+
+Why did the `.then` trigger afterwards? What's going on?
+
+# Microtasks
+
+Asynchronous tasks need proper management. For that, the standard specifies an internal queue `PromiseJobs`, more often referred to as "microtask queue" (v8 term).
+
+As said in the [specification](https://tc39.github.io/ecma262/#sec-jobs-and-job-queues):
+
+- The queue is first-in-first-out: tasks enqueued first are run first.
+- Execution of a task is initiated only when nothing else is running.
+
+Or, to say that simply, when a promise is ready, its `.then/catch/finally` handlers are put into the queue. They are not executed yet. JavaScript engine takes a task from the queue and executes it, when it becomes free from the current code.
+
+That's why "code finished" in the example above shows first.
+
+![](promiseQueue.png)
+
+Promise handlers always go through that internal queue.
+
+If there's a chain with multiple `.then/catch/finally`, then every one of them is executed asynchronously. That is, it first gets queued, and executed when the current code is complete and previously queued handlers are finished.
+
+**What if the order matters for us? How can we make `code finished` work after `promise done`?**
+
+Easy, just put it into the queue with `.then`:
+
+```js run
+Promise.resolve()
+  .then(() => alert("promise done!"))
+  .then(() => alert("code finished"));
+```
+
+Now the order is as intended.
+
+## Event loop
+
+In-browser JavaScript, as well as Node.js, is based on an *event loop*.
+
+"Event loop" is a process when the engine sleeps and waits for events, then reacts on those and sleeps again.
+
+Examples of events:
+- `mousemove`, a user moved their mouse.
+- `setTimeout` handler is to be called.
+- an external `<script src="...">` is loaded, ready to be executed.
+- a network operation, e.g. `fetch` is complete.
+- ...etc.
+
+Things happen -- the engine handles them -- and waits for more to happen (while sleeping and consuming close to zero CPU).
+
+![](eventLoop.png)
+
+As you can see, there's also a queue here. A so-called "macrotask queue" (v8 term).
+
+When an event happens, while the engine is busy, its handling is enqueued.
+
+For instance, while the engine is busy processing a network `fetch`, a user may move their mouse causing `mousemove`, and `setTimeout` may be due and so on, just as painted on the picture above.
+
+Events from the macrotask queue are processed on "first come – first served" basis. When the engine browser finishes with `fetch`, it handles `mousemove` event, then `setTimeout` handler, and so on.
+
+So far, quite simple, right? The engine is busy, so other tasks queue up.
+
+Now the important stuff.
+
+**Microtask queue has a higher priority than the macrotask queue.**
+
+In other words, the engine first executes all microtasks, and then takes a macrotask. Promise handling always has the priority.
+
+For instance, take a look:
+
+```js run
+setTimeout(() => alert("timeout"));
+
+Promise.resolve()
+  .then(() => alert("promise"));
+
+alert("code");
+```
+
+What's the order?
+
+1. `code` shows first, because it's a regular synchronous call.
+2. `promise` shows second, because `.then` passes through the microtask queue, and runs after the current code.
+3. `timeout` shows last, because it's a macrotask.
+
+It may happen that while handling a macrotask, new promises are created.
+
+Or, vice-versa, a microtask schedules a macrotask (e.g. `setTimeout`).
+
+For instance, here `.then` schedules a `setTimeout`:
+
+```js run
+Promise.resolve()
+  .then(() => {
+    setTimeout(() => alert("timeout"), 0);
+  })
+  .then(() => {
+    alert("promise");
+  });
+```
+
+Naturally, `promise` shows up first, because `setTimeout` macrotask awaits in the less-priority macrotask queue.
+
+As a logical consequence, macrotasks are handled only when promises give the engine a "free time". So if we have a promise chain that doesn't wait for anything, then things like `setTimeout` or event handlers can never get in the middle.
+
+
+## Unhandled rejection
+
+Remember "unhandled rejection" event from the chapter <info:promise-error-handling>?
+
+Now, with the understanding of microtasks, we can formalize it.
+
+**"Unhandled rejection" is when a promise error is not handled at the end of the microtask queue.**
+
+For instance, consider this code:
+
+```js run
+let promise = Promise.reject(new Error("Promise Failed!"));
+
+window.addEventListener('unhandledrejection', event => {
+  alert(event.reason); // Promise Failed!
+});
+```
+
+We create a rejected `promise` and do not handle the error. So we have the "unhandled rejection" event (printed in browser console too).
+
+We wouldn't have it if we added `.catch`, like this:
+
+```js run
+let promise = Promise.reject(new Error("Promise Failed!"));
+*!*
+promise.catch(err => alert('caught'));
+*/!*
+
+// no error, all quiet
+window.addEventListener('unhandledrejection', event => alert(event.reason));
+```
+
+Now let's say, we'll be catching the error, but after `setTimeout`:
+
+```js run
+let promise = Promise.reject(new Error("Promise Failed!"));
+*!*
+setTimeout(() => promise.catch(err => alert('caught')));
+*/!*
+
+// Error: Promise Failed!
+window.addEventListener('unhandledrejection', event => alert(event.reason));
+```
+
+Now the unhandled rejction appears again. Why? Because `unhandledrejection` triggers when the microtask queue is complete. The engine examines promises and, if any of them is in "rejected" state, then the event is generated.
+
+In the example, the `.catch` added by `setTimeout` triggers too, of course it does, but later, after `unhandledrejection` has already occurred.
+
+## Summary
+
+- Promise handling is always asynchronous, as all promise actions pass through the internal "promise jobs" queue, also called "microtask queue" (v8 term).
+
+    **So, `.then/catch/finally` are called after the current code is finished.**
+
+    If we need to guarantee that a piece of code is executed after `.then/catch/finally`, it's best to add it into a chained `.then` call.
+
+- There's also a "macrotask queue" that keeps various events, network operation results, `setTimeout`-scheduled calls, and so on. These are also called "macrotasks" (v8 term).
+
+    The engine uses the macrotask queue to handle them in the appearance order.
+
+    **Macrotasks run after the code is finished *and* after the microtask queue is empty.**
+
+    In other words, they have lower priority.
+
+So the order is: regular code, then promise handling, then everything else, like events etc.
diff --git a/1-js/11-async/07-microtask-queue/eventLoop.png b/1-js/11-async/07-microtask-queue/eventLoop.png
new file mode 100644
index 000000000..f63c44296
Binary files /dev/null and b/1-js/11-async/07-microtask-queue/eventLoop.png differ
diff --git a/1-js/11-async/07-microtask-queue/eventLoop@2x.png b/1-js/11-async/07-microtask-queue/eventLoop@2x.png
new file mode 100644
index 000000000..27ece0219
Binary files /dev/null and b/1-js/11-async/07-microtask-queue/eventLoop@2x.png differ
diff --git a/1-js/11-async/07-microtask-queue/promiseQueue.png b/1-js/11-async/07-microtask-queue/promiseQueue.png
new file mode 100644
index 000000000..efccc0140
Binary files /dev/null and b/1-js/11-async/07-microtask-queue/promiseQueue.png differ
diff --git a/1-js/11-async/07-microtask-queue/promiseQueue@2x.png b/1-js/11-async/07-microtask-queue/promiseQueue@2x.png
new file mode 100644
index 000000000..4d6ae5b42
Binary files /dev/null and b/1-js/11-async/07-microtask-queue/promiseQueue@2x.png differ
diff --git a/6-async/05-async-await/01-rewrite-async/solution.md b/1-js/11-async/08-async-await/01-rewrite-async/solution.md
similarity index 100%
rename from 6-async/05-async-await/01-rewrite-async/solution.md
rename to 1-js/11-async/08-async-await/01-rewrite-async/solution.md
diff --git a/6-async/05-async-await/01-rewrite-async/task.md b/1-js/11-async/08-async-await/01-rewrite-async/task.md
similarity index 100%
rename from 6-async/05-async-await/01-rewrite-async/task.md
rename to 1-js/11-async/08-async-await/01-rewrite-async/task.md
diff --git a/6-async/05-async-await/01-rewrite-async-2/solution.md b/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md
similarity index 100%
rename from 6-async/05-async-await/01-rewrite-async-2/solution.md
rename to 1-js/11-async/08-async-await/02-rewrite-async-2/solution.md
diff --git a/6-async/05-async-await/01-rewrite-async-2/task.md b/1-js/11-async/08-async-await/02-rewrite-async-2/task.md
similarity index 100%
rename from 6-async/05-async-await/01-rewrite-async-2/task.md
rename to 1-js/11-async/08-async-await/02-rewrite-async-2/task.md
diff --git a/1-js/11-async/08-async-await/03-async-from-regular/solution.md b/1-js/11-async/08-async-await/03-async-from-regular/solution.md
new file mode 100644
index 000000000..7e2ab597e
--- /dev/null
+++ b/1-js/11-async/08-async-await/03-async-from-regular/solution.md
@@ -0,0 +1,20 @@
+
+That's the case when knowing how it works inside is helpful.
+
+Just treat `async` call as promise and attach `.then` to it:
+```js run
+async function wait() {
+  await new Promise(resolve => setTimeout(resolve, 1000));
+
+  return 10;
+}
+
+function f() {
+  // shows 10 after 1 second
+*!*
+  wait().then(result => alert(result));
+*/!*
+}
+
+f();
+```
diff --git a/1-js/11-async/08-async-await/03-async-from-regular/task.md b/1-js/11-async/08-async-await/03-async-from-regular/task.md
new file mode 100644
index 000000000..18d0e2ce7
--- /dev/null
+++ b/1-js/11-async/08-async-await/03-async-from-regular/task.md
@@ -0,0 +1,20 @@
+
+# Call async from non-async
+
+We have a "regular" function. How to call `async` from it and use its result?
+
+```js
+async function wait() {
+  await new Promise(resolve => setTimeout(resolve, 1000));
+
+  return 10;
+}
+
+function f() {
+  // ...what to write here?
+  // we need to call async wait() and wait to get 10
+  // remember, we can't use "await"
+}
+```
+
+P.S. The task is technically very simple, but the question is quite common for developers new to async/await.
diff --git a/6-async/05-async-await/article.md b/1-js/11-async/08-async-await/article.md
similarity index 74%
rename from 6-async/05-async-await/article.md
rename to 1-js/11-async/08-async-await/article.md
index dfa42978e..041a5a465 100644
--- a/6-async/05-async-await/article.md
+++ b/1-js/11-async/08-async-await/article.md
@@ -12,7 +12,7 @@ async function f() {
 }
 ```
 
-The word "async" before a function means one simple thing: a function always returns a promise. If the code has `return <non-promise>` in it, then JavaScript automatically wraps it into a resolved promise with that value.
+The word "async" before a function means one simple thing: a function always returns a promise. Even If a function actually returns a non-promise value, prepending the function definition with the "async" keyword directs JavaScript to automatically wrap that value in a resolved promise.
 
 For instance, the code above returns a resolved promise with the result of `1`, let's test it:
 
@@ -24,7 +24,7 @@ async function f() {
 f().then(alert); // 1
 ```
 
-...We could explicitly return a promise, that would be the same:
+...We could explicitly return a promise, that would be the same as:
 
 ```js run
 async function f() {
@@ -72,7 +72,7 @@ Let's emphasize: `await` literally makes JavaScript wait until the promise settl
 It's just a more elegant syntax of getting the promise result than `promise.then`, easier to read and write.
 
 ````warn header="Can't use `await` in regular functions"
-If we try to use `await` in non-async function, that would be a syntax error:
+If we try to use `await` in non-async function, there would be a syntax error:
 
 ```js run
 function f() {
@@ -83,12 +83,12 @@ function f() {
 }
 ```
 
-We can get such error in case if we forget to put `async` before a function. As said, `await` only works inside `async function`.
+We will get this error if we do not put `async` before a function. As said, `await` only works inside an `async function`.
 ````
 
-Let's take `showAvatar()` example from the chapter <info:promise-chaining> and rewrite it using `async/await`:
+Let's take the `showAvatar()` example from the chapter <info:promise-chaining> and rewrite it using `async/await`:
 
-1. We'll need to replace `.then` calls by `await`.
+1. We'll need to replace `.then` calls with `await`.
 2. Also we should make the function `async` for them to work.
 
 ```js run
@@ -122,7 +122,7 @@ showAvatar();
 Pretty clean and easy to read, right? Much better than before.
 
 ````smart header="`await` won't work in the top-level code"
-People who are just starting to use `await` tend to forget that, but we can't write `await` in the top-level code. That wouldn't work:
+People who are just starting to use `await` tend to forget the fact that we can't use `await` in top-level code. For example, this will not work:
 
 ```js run
 // syntax error in top-level code
@@ -130,19 +130,30 @@ let response = await fetch('/article/promise-chaining/user.json');
 let user = await response.json();
 ```
 
-So we need to have a wrapping async function for the code that awaits. Just as in the example above.
+We can wrap it into an anonymous async function, like this:
+
+```js run
+(async () => {
+  let response = await fetch('/article/promise-chaining/user.json');
+  let user = await response.json();
+  ...
+})();
+```
+
+
 ````
-````smart header="`await` accepts thenables"
-Like `promise.then`, `await` allows to use thenable objects (those with a callable `then` method). Again, the idea is that a 3rd-party object may not be a promise, but promise-compatible: if it supports `.then`, that's enough to use with `await`.
+````smart header="`await` accepts \"thenables\""
+Like `promise.then`, `await` allows to use thenable objects (those with a callable `then` method). The idea is that a 3rd-party object may not be a promise, but promise-compatible: if it supports `.then`, that's enough to use with `await`.
+
+Here's a demo `Thenable` class, the `await` below accepts its instances:
 
-For instance, here `await` accepts `new Thenable(1)`:
 ```js run
 class Thenable {
   constructor(num) {
     this.num = num;
   }
   then(resolve, reject) {
-    alert(resolve); // function() { native code }
+    alert(resolve);
     // resolve with this.num*2 after 1000ms
     setTimeout(() => resolve(this.num * 2), 1000); // (*)
   }
@@ -161,9 +172,7 @@ If `await` gets a non-promise object with `.then`, it calls that method providin
 ````
 
 ````smart header="Async methods"
-A class method can also be async, just put `async` before it.
-
-Like here:
+To declare an async class method, just prepend it with `async`:
 
 ```js run
 class Waiter {
@@ -254,7 +263,7 @@ f().catch(alert); // TypeError: failed to fetch // (*)
 */!*
 ```
 
-If we forget to add `.catch` there, then we get an unhandled promise error (and can see it in the console). We can catch such errors using a global event handler as described in the chapter <info:promise-chaining>.
+If we forget to add `.catch` there, then we get an unhandled promise error (viewable in the console). We can catch such errors using a global event handler as described in the chapter <info:promise-error-handling>.
 
 
 ```smart header="`async/await` and `promise.then/catch`"
@@ -281,6 +290,34 @@ In case of an error, it propagates as usual: from the failed promise to `Promise
 
 ````
 
+## Microtask queue [#microtask-queue]
+
+As we've seen in the chapter <info:microtask-queue>, promise handlers are executed asynchronously. Every `.then/catch/finally` handler first gets into the "microtask queue" and executed after the current code is complete.
+
+`Async/await` is based on promises, so it uses the same microtask queue internally, and has the similar priority over macrotasks.
+
+For instance, we have:
+- `setTimeout(handler, 0)`, that should run `handler` with zero delay.
+- `let x = await f()`, function `f()` is async, but returns immediately.
+
+Which one runs first if `await` is *below* `setTimeout` in the code?
+
+```js run
+async function f() {
+  return 1;
+}
+
+(async () => {
+    setTimeout(() => alert('timeout'), 0);
+
+    await f();
+
+    alert('await');
+})();
+```
+
+There's no ambiguity here: `await` always finishes first, because (as a microtask) it has a higher priority than `setTimeout` handling.
+
 ## Summary
 
 The `async` keyword before a function has two effects:
diff --git a/6-async/05-async-await/head.html b/1-js/11-async/08-async-await/head.html
similarity index 100%
rename from 6-async/05-async-await/head.html
rename to 1-js/11-async/08-async-await/head.html
diff --git a/6-async/index.md b/1-js/11-async/index.md
similarity index 100%
rename from 6-async/index.md
rename to 1-js/11-async/index.md
diff --git a/1-js/12-generators-iterators/1-generators/01-pseudo-random-generator/_js.view/solution.js b/1-js/12-generators-iterators/1-generators/01-pseudo-random-generator/_js.view/solution.js
new file mode 100644
index 000000000..45c8b071b
--- /dev/null
+++ b/1-js/12-generators-iterators/1-generators/01-pseudo-random-generator/_js.view/solution.js
@@ -0,0 +1,9 @@
+function* pseudoRandom(seed) {
+  let value = seed;
+
+  while(true) {
+    value = value * 16807 % 2147483647
+    yield value;
+  }
+
+};
diff --git a/1-js/12-generators-iterators/1-generators/01-pseudo-random-generator/_js.view/test.js b/1-js/12-generators-iterators/1-generators/01-pseudo-random-generator/_js.view/test.js
new file mode 100644
index 000000000..5f3a0ae87
--- /dev/null
+++ b/1-js/12-generators-iterators/1-generators/01-pseudo-random-generator/_js.view/test.js
@@ -0,0 +1,21 @@
+describe("pseudoRandom", function() {
+
+  it("follows the formula", function() {
+    let generator = pseudoRandom(1);
+
+    assert.equal(generator.next().value, 16807);
+    assert.equal(generator.next().value, 282475249);
+    assert.equal(generator.next().value, 1622650073);
+  });
+
+
+  it("returns same value for the same seed", function() {
+    let generator1 = pseudoRandom(123);
+    let generator2 = pseudoRandom(123);
+
+    assert.deepEqual(generator1.next(), generator2.next());
+    assert.deepEqual(generator1.next(), generator2.next());
+    assert.deepEqual(generator1.next(), generator2.next());
+  });
+
+});
diff --git a/1-js/12-generators-iterators/1-generators/01-pseudo-random-generator/solution.md b/1-js/12-generators-iterators/1-generators/01-pseudo-random-generator/solution.md
new file mode 100644
index 000000000..8bb521506
--- /dev/null
+++ b/1-js/12-generators-iterators/1-generators/01-pseudo-random-generator/solution.md
@@ -0,0 +1,38 @@
+```js run demo
+function* pseudoRandom(seed) {
+  let value = seed;
+
+  while(true) {
+    value = value * 16807 % 2147483647
+    yield value;
+  }
+
+};
+
+let generator = pseudoRandom(1);
+
+alert(generator.next().value); // 16807
+alert(generator.next().value); // 282475249
+alert(generator.next().value); // 1622650073
+```
+
+Please note, the same can be done with a regular function, like this:
+
+```js run
+function pseudoRandom(seed) {
+  let value = seed;
+
+  return function() {
+    value = value * 16807 % 2147483647;
+    return value;
+  }
+}
+
+let generator = pseudoRandom(1);
+
+alert(generator()); // 16807
+alert(generator()); // 282475249
+alert(generator()); // 1622650073
+```
+
+That's fine for this context. But then we loose ability to iterate with `for..of` and to use generator composition, that may be useful elsewhere.
diff --git a/1-js/12-generators-iterators/1-generators/01-pseudo-random-generator/task.md b/1-js/12-generators-iterators/1-generators/01-pseudo-random-generator/task.md
new file mode 100644
index 000000000..c2ac53181
--- /dev/null
+++ b/1-js/12-generators-iterators/1-generators/01-pseudo-random-generator/task.md
@@ -0,0 +1,34 @@
+
+# Pseudo-random generator
+
+There are many areas where we need random data.
+
+One of them is testing. We may need random data: text, numbers etc, to test things out well.
+
+In JavaScript, we could use `Math.random()`. But if something goes wrong, we'd like to be able to repeat the test, using exactly the same data.
+
+For that, so called "seeded pseudo-random generators" are used. They take a "seed", the first value, and then generate next ones using a formula. So that the same seed yields the same sequence, and hence the whole flow is easily reproducible. We only need to remember the seed to repeat it.
+
+An example of such formula, that generates somewhat uniformly distributed values:
+
+```
+next = previous * 16807 % 2147483647
+```
+
+If we use `1` as the seed, the values will be:
+1. `16807`
+2. `282475249`
+3. `1622650073`
+4. ...and so on...
+
+The task is to create a generator function `pseudoRandom(seed)` that takes `seed` and creates the generator with this formula.
+
+Usage example:
+
+```js
+let generator = pseudoRandom(1);
+
+alert(generator.next().value); // 16807
+alert(generator.next().value); // 282475249
+alert(generator.next().value); // 1622650073
+```
diff --git a/1-js/12-generators-iterators/1-generators/anon.png b/1-js/12-generators-iterators/1-generators/anon.png
new file mode 100644
index 000000000..a1675d2fe
Binary files /dev/null and b/1-js/12-generators-iterators/1-generators/anon.png differ
diff --git a/1-js/12-generators-iterators/1-generators/article.md b/1-js/12-generators-iterators/1-generators/article.md
new file mode 100644
index 000000000..93a53777d
--- /dev/null
+++ b/1-js/12-generators-iterators/1-generators/article.md
@@ -0,0 +1,469 @@
+
+# Generators
+
+Regular functions return only one, single value (or nothing).
+
+Generators can return ("yield") multiple values, possibly an infinite number of values, one after another, on-demand. They work great with [iterables](info:iterable), allowing to create data streams with ease.
+
+## Generator functions
+
+To create a generator, we need a special syntax construct: `function*`, so-called "generator function".
+
+It looks like this:
+
+```js
+function* generateSequence() {
+  yield 1;
+  yield 2;
+  return 3;
+}
+```
+
+When `generateSequence()` is called, it does not execute the code. Instead, it returns a special object, called "generator".
+
+```js
+// "generator function" creates "generator object"
+let generator = generateSequence();
+```
+
+The `generator` object can be perceived as a "frozen function call":
+
+![](generateSequence-1.png)
+
+Upon creation, the code execution is paused at the very beginning.
+
+The main method of a generator is `next()`. When called, it resumes execution till the nearest `yield <value>` statement. Then the execution pauses, and the value is returned to the outer code.
+
+For instance, here we create the generator and get its first yielded value:
+
+```js run
+function* generateSequence() {
+  yield 1;
+  yield 2;
+  return 3;
+}
+
+let generator = generateSequence();
+
+*!*
+let one = generator.next();
+*/!*
+
+alert(JSON.stringify(one)); // {value: 1, done: false}
+```
+
+The result of `next()` is always an object:
+- `value`: the yielded value.
+- `done`: `false` if the code is not finished yet, otherwise `true`.
+
+As of now, we got the first value only:
+
+![](generateSequence-2.png)
+
+Let's call `generator.next()` again. It resumes the execution and returns the next `yield`:
+
+```js
+let two = generator.next();
+
+alert(JSON.stringify(two)); // {value: 2, done: false}
+```
+
+![](generateSequence-3.png)
+
+And, if we call it the third time, then the execution reaches `return` statement that finishes the function:
+
+```js
+let three = generator.next();
+
+alert(JSON.stringify(three)); // {value: 3, *!*done: true*/!*}
+```
+
+![](generateSequence-4.png)
+
+Now the generator is done. We should see it from `done:true` and process `value:3` as the final result.
+
+New calls `generator.next()` don't make sense any more. If we make them, they return the same object: `{done: true}`.
+
+There's no way to "roll back" a generator. But we can create another one by calling `generateSequence()`.
+
+So far, the most important thing to understand is that generator functions, unlike regular function, do not run the code. They serve as "generator factories". Running `function*` returns a generator, and then we ask it for values.
+
+```smart header="`function* f(…)` or `function *f(…)`?"
+That's a minor religious question, both syntaxes are correct.
+
+But usually the first syntax is preferred, as the star `*` denotes that it's a generator function, it describes the kind, not the name, so it should stick with the `function` keyword.
+```
+
+## Generators are iterable
+
+As you probably already guessed looking at the `next()` method, generators are [iterable](info:iterable).
+
+We can get loop over values by `for..of`:
+
+```js run
+function* generateSequence() {
+  yield 1;
+  yield 2;
+  return 3;
+}
+
+let generator = generateSequence();
+
+for(let value of generator) {
+  alert(value); // 1, then 2
+}
+```
+
+That's a much better-looking way to work with generators than calling `.next().value`, right?
+
+...But please note: the example above shows `1`, then `2`, and that's all. It doesn't show `3`!
+
+It's because for-of iteration ignores the last `value`, when `done: true`. So, if we want all results to be shown by `for..of`, we must return them with `yield`:
+
+```js run
+function* generateSequence() {
+  yield 1;
+  yield 2;
+*!*
+  yield 3;
+*/!*
+}
+
+let generator = generateSequence();
+
+for(let value of generator) {
+  alert(value); // 1, then 2, then 3
+}
+```
+
+Naturally, as generators are iterable, we can call all related functionality, e.g. the spread operator `...`:
+
+```js run
+function* generateSequence() {
+  yield 1;
+  yield 2;
+  yield 3;
+}
+
+let sequence = [0, ...generateSequence()];
+
+alert(sequence); // 0, 1, 2, 3
+```
+
+In the code above, `...generateSequence()` turns the iterable into array of items (read more about the spread operator in the chapter [](info:rest-parameters-spread-operator#spread-operator))
+
+## Using generators instead of iterables
+
+Some time ago, in the chapter [](info:iterable) we created an iterable `range` object that returns values `from..to`.
+
+Here, let's remember the code:
+
+```js run
+let range = {
+  from: 1,
+  to: 5,
+
+  // for..of calls this method once in the very beginning
+  [Symbol.iterator]() {
+    // ...it returns the iterator object:
+    // onward, for..of works only with that object, asking it for next values
+    return {
+      current: this.from,
+      last: this.to,
+
+      // next() is called on each iteration by the for..of loop
+      next() {
+        // it should return the value as an object {done:.., value :...}
+        if (this.current <= this.last) {
+          return { done: false, value: this.current++ };
+        } else {
+          return { done: true };
+        }
+      }
+    };
+  }
+};
+
+alert([...range]); // 1,2,3,4,5
+```
+
+Using a generator to make iterable sequences is so much more elegant:
+
+```js run
+function* generateSequence(start, end) {
+  for (let i = start; i <= end; i++) {
+    yield i;
+  }
+}
+
+let sequence = [...generateSequence(1,5)];
+
+alert(sequence); // 1, 2, 3, 4, 5
+```
+
+...But what if we'd like to keep a custom `range` object?
+
+## Converting Symbol.iterator to generator
+
+We can get the best from both worlds by providing a generator as `Symbol.iterator`:
+
+```js run
+let range = {
+  from: 1,
+  to: 5,
+
+  *[Symbol.iterator]() { // a shorthand for [Symbol.iterator]: function*()
+    for(let value = this.from; value <= this.to; value++) {
+      yield value;
+    }
+  }
+};
+
+alert( [...range] ); // 1,2,3,4,5
+```
+
+The `range` object is now iterable.
+
+That works pretty well, because when `range[Symbol.iterator]` is called:
+- it returns an object (now a generator)
+- that has `.next()` method (yep, a generator has it)
+- that returns values in the form `{value: ..., done: true/false}` (check, exactly what generator does).
+
+That's not a coincidence, of course. Generators aim to make iterables easier, so we can see that.
+
+The last variant with a generator is much more concise than the original iterable code, and keeps the same functionality.
+
+```smart header="Generators may continue forever"
+In the examples above we generated finite sequences, but we can also make a generator that yields values forever. For instance, an unending sequence of pseudo-random numbers.
+
+That surely would require a `break` in `for..of`, otherwise the loop would repeat forever and hang.
+```
+
+## Generator composition
+
+Generator composition is a special feature of generators that allows to transparently "embed" generators in each other.
+
+For instance, we'd like to generate a sequence of:
+- digits `0..9` (character codes 48..57),
+- followed by alphabet letters `a..z` (character codes 65..90)
+- followed by uppercased letters `A..Z` (character codes 97..122)
+
+Then we plan to create passwords by selecting characters from it (could add syntax characters as well), but need to generate the sequence first.
+
+We already have `function* generateSequence(start, end)`. Let's reuse it to deliver 3 sequences one after another, together they are exactly what we need.
+
+In a regular function, to combine results from multiple other functions, we call them, store the results, and then join at the end.
+
+For generators, we can do better, like this:
+
+```js run
+function* generateSequence(start, end) {
+  for (let i = start; i <= end; i++) yield i;
+}
+
+function* generatePasswordCodes() {
+
+*!*
+  // 0..9
+  yield* generateSequence(48, 57);
+
+  // A..Z
+  yield* generateSequence(65, 90);
+
+  // a..z
+  yield* generateSequence(97, 122);
+*/!*
+
+}
+
+let str = '';
+
+for(let code of generatePasswordCodes()) {
+  str += String.fromCharCode(code);
+}
+
+alert(str); // 0..9A..Za..z
+```
+
+The special `yield*` directive in the example is responsible for the composition. It *delegates* the execution to another generator. Or, to say it simple, it runs generators and transparently forwards their yields outside, as if they were done by the calling generator itself.
+
+The result is the same as if we inlined the code from nested generators:
+
+```js run
+function* generateSequence(start, end) {
+  for (let i = start; i <= end; i++) yield i;
+}
+
+function* generateAlphaNum() {
+
+*!*
+  // yield* generateSequence(48, 57);
+  for (let i = 48; i <= 57; i++) yield i;
+
+  // yield* generateSequence(65, 90);
+  for (let i = 65; i <= 90; i++) yield i;
+
+  // yield* generateSequence(97, 122);
+  for (let i = 97; i <= 122; i++) yield i;
+*/!*
+
+}
+
+let str = '';
+
+for(let code of generateAlphaNum()) {
+  str += String.fromCharCode(code);
+}
+
+alert(str); // 0..9A..Za..z
+```
+
+A generator composition is a natural way to insert a flow of one generator into another.
+
+It works even if the flow of values from the nested generator is infinite. It's simple and doesn't use extra memory to store intermediate results.
+
+## "yield" is a two-way road
+
+Till this moment, generators were like "iterators on steroids". And that's how they are often used.
+
+But in fact they are much more powerful and flexible.
+
+That's because `yield` is a two-way road: it not only returns the result outside, but also can pass the value inside the generator.
+
+To do so, we should call `generator.next(arg)`, with an argument. That argument becomes the result of `yield`.
+
+Let's see an example:
+
+```js run
+function* gen() {
+*!*
+  // Pass a question to the outer code and wait for an answer
+  let result = yield "2 + 2?"; // (*)
+*/!*
+
+  alert(result);
+}
+
+let generator = gen();
+
+let question = generator.next().value; // <-- yield returns the value
+
+generator.next(4); // --> pass the result into the generator  
+```
+
+![](genYield2.png)
+
+1. The first call `generator.next()` is always without an argument. It starts the execution and returns the result of the first `yield` ("2+2?"). At this point the generator pauses the execution (still on that line).
+2. Then, as shown at the picture above, the result of `yield` gets into the `question` variable in the calling code.
+3. On `generator.next(4)`, the generator resumes, and `4` gets in as the result: `let result = 4`.
+
+Please note, the outer code does not have to immediately call`next(4)`. It may take time to calculate the value. This is also a valid code:
+
+```js
+// resume the generator after some time
+setTimeout(() => generator.next(4), 1000);
+```
+
+The syntax may seem a bit odd. It's quite uncommon for a function and the calling code to pass values around to each other. But that's exactly what's going on.
+
+To make things more obvious, here's another example, with more calls:
+
+```js run
+function* gen() {
+  let ask1 = yield "2 + 2?";
+
+  alert(ask1); // 4
+
+  let ask2 = yield "3 * 3?"
+
+  alert(ask2); // 9
+}
+
+let generator = gen();
+
+alert( generator.next().value ); // "2 + 2?"
+
+alert( generator.next(4).value ); // "3 * 3?"
+
+alert( generator.next(9).done ); // true
+```
+
+The execution picture:
+
+![](genYield2-2.png)
+
+1. The first `.next()` starts the execution... It reaches the first `yield`.
+2. The result is returned to the outer code.
+3. The second `.next(4)` passes `4` back to the generator as the result of the first `yield`, and resumes the execution.
+4. ...It reaches the second `yield`, that becomes the result of the generator call.
+5. The third `next(9)` passes `9` into the generator as the result of the second `yield` and resumes the execution that reaches the end of the function, so `done: true`.
+
+It's like a "ping-pong" game. Each `next(value)` (excluding the first one) passes a value into the generator, that becomes the result of the current `yield`, and then gets back the result of the next `yield`.
+
+## generator.throw
+
+As we observed in the examples above, the outer code may pass a value into the generator, as the result of `yield`.
+
+...But it can also initiate (throw) an error there. That's natural, as an error is a kind of result.
+
+To pass an error into a `yield`, we should call `generator.throw(err)`. In that case, the `err` is thrown in the line with that `yield`.
+
+For instance, here the yield of `"2 + 2?"` leads to an error:
+
+```js run
+function* gen() {
+  try {
+    let result = yield "2 + 2?"; // (1)
+
+    alert("The execution does not reach here, because the exception is thrown above");
+  } catch(e) {
+    alert(e); // shows the error
+  }
+}
+
+let generator = gen();
+
+let question = generator.next().value;
+
+*!*
+generator.throw(new Error("The answer is not found in my database")); // (2)
+*/!*
+```
+
+The error, thrown into the generator at the line `(2)` leads to an exception in the line `(1)` with `yield`. In the example above, `try..catch` catches it and shows.
+
+If we don't catch it, then just like any exception, it "falls out" the generator into the calling code.
+
+The current line of the calling code is the line with `generator.throw`, labelled as `(2)`. So we can catch it here, like this:
+
+```js run
+function* generate() {
+  let result = yield "2 + 2?"; // Error in this line
+}
+
+let generator = generate();
+
+let question = generator.next().value;
+
+*!*
+try {
+  generator.throw(new Error("The answer is not found in my database"));
+} catch(e) {
+  alert(e); // shows the error
+}
+*/!*
+```
+
+If we don't catch the error there, then, as usual, it falls through to the outer calling code (if any) and, if uncaught, kills the script.
+
+## Summary
+
+- Generators are created by generator functions `function*(…) {…}`.
+- Inside generators (only) there exists a `yield` operator.
+- The outer code and the generator may exchange results via `next/yield` calls.
+
+In modern JavaScript, generators are rarely used. But sometimes they come in handy, because the ability of a function to exchange data with the calling code during the execution is quite unique.
+
+Also, in the next chapter we'll learn async generators, which are used to read streams of asynchronously generated data in `for` loop.
+
+In web-programming we often work with streamed data, e.g. need to fetch paginated results, so that's a very important use case.
diff --git a/1-js/12-generators-iterators/1-generators/genYield2-2.png b/1-js/12-generators-iterators/1-generators/genYield2-2.png
new file mode 100644
index 000000000..d9e891930
Binary files /dev/null and b/1-js/12-generators-iterators/1-generators/genYield2-2.png differ
diff --git a/1-js/12-generators-iterators/1-generators/genYield2-2@2x.png b/1-js/12-generators-iterators/1-generators/genYield2-2@2x.png
new file mode 100644
index 000000000..ef2fcf6b4
Binary files /dev/null and b/1-js/12-generators-iterators/1-generators/genYield2-2@2x.png differ
diff --git a/1-js/12-generators-iterators/1-generators/genYield2-3.png b/1-js/12-generators-iterators/1-generators/genYield2-3.png
new file mode 100644
index 000000000..102ec4513
Binary files /dev/null and b/1-js/12-generators-iterators/1-generators/genYield2-3.png differ
diff --git a/1-js/12-generators-iterators/1-generators/genYield2-3@2x.png b/1-js/12-generators-iterators/1-generators/genYield2-3@2x.png
new file mode 100644
index 000000000..8cdf19d08
Binary files /dev/null and b/1-js/12-generators-iterators/1-generators/genYield2-3@2x.png differ
diff --git a/1-js/12-generators-iterators/1-generators/genYield2.png b/1-js/12-generators-iterators/1-generators/genYield2.png
new file mode 100644
index 000000000..7d3d9ace3
Binary files /dev/null and b/1-js/12-generators-iterators/1-generators/genYield2.png differ
diff --git a/1-js/12-generators-iterators/1-generators/genYield2@2x.png b/1-js/12-generators-iterators/1-generators/genYield2@2x.png
new file mode 100644
index 000000000..de51a3c94
Binary files /dev/null and b/1-js/12-generators-iterators/1-generators/genYield2@2x.png differ
diff --git a/1-js/12-generators-iterators/1-generators/generateSequence-1.png b/1-js/12-generators-iterators/1-generators/generateSequence-1.png
new file mode 100644
index 000000000..f6c1cfb5d
Binary files /dev/null and b/1-js/12-generators-iterators/1-generators/generateSequence-1.png differ
diff --git a/1-js/12-generators-iterators/1-generators/generateSequence-1@2x.png b/1-js/12-generators-iterators/1-generators/generateSequence-1@2x.png
new file mode 100644
index 000000000..74f2f1b91
Binary files /dev/null and b/1-js/12-generators-iterators/1-generators/generateSequence-1@2x.png differ
diff --git a/1-js/12-generators-iterators/1-generators/generateSequence-2.png b/1-js/12-generators-iterators/1-generators/generateSequence-2.png
new file mode 100644
index 000000000..1978a864c
Binary files /dev/null and b/1-js/12-generators-iterators/1-generators/generateSequence-2.png differ
diff --git a/1-js/12-generators-iterators/1-generators/generateSequence-2@2x.png b/1-js/12-generators-iterators/1-generators/generateSequence-2@2x.png
new file mode 100644
index 000000000..f26afaf98
Binary files /dev/null and b/1-js/12-generators-iterators/1-generators/generateSequence-2@2x.png differ
diff --git a/1-js/12-generators-iterators/1-generators/generateSequence-3.png b/1-js/12-generators-iterators/1-generators/generateSequence-3.png
new file mode 100644
index 000000000..b32d91eaf
Binary files /dev/null and b/1-js/12-generators-iterators/1-generators/generateSequence-3.png differ
diff --git a/1-js/12-generators-iterators/1-generators/generateSequence-3@2x.png b/1-js/12-generators-iterators/1-generators/generateSequence-3@2x.png
new file mode 100644
index 000000000..42dd4a2db
Binary files /dev/null and b/1-js/12-generators-iterators/1-generators/generateSequence-3@2x.png differ
diff --git a/1-js/12-generators-iterators/1-generators/generateSequence-4.png b/1-js/12-generators-iterators/1-generators/generateSequence-4.png
new file mode 100644
index 000000000..428b4226b
Binary files /dev/null and b/1-js/12-generators-iterators/1-generators/generateSequence-4.png differ
diff --git a/1-js/12-generators-iterators/1-generators/generateSequence-4@2x.png b/1-js/12-generators-iterators/1-generators/generateSequence-4@2x.png
new file mode 100644
index 000000000..fc9f286a4
Binary files /dev/null and b/1-js/12-generators-iterators/1-generators/generateSequence-4@2x.png differ
diff --git a/1-js/12-generators-iterators/2-async-iterators-generators/article.md b/1-js/12-generators-iterators/2-async-iterators-generators/article.md
new file mode 100644
index 000000000..45cf73938
--- /dev/null
+++ b/1-js/12-generators-iterators/2-async-iterators-generators/article.md
@@ -0,0 +1,361 @@
+
+# Async iterators and generators
+
+Asynchronous iterators allow to iterate over data that comes asynchronously, on-demand.
+
+For instance, when we download something chunk-by-chunk, or just expect events to come asynchronously and would like to iterate over them -- async iterators and generators may come in handy. Let's see a simple example first, to grasp the syntax, and then review a real-life use case.
+
+## Async iterators
+
+Asynchronous iterators are totally similar to regular iterators, with a few syntactic differences.
+
+"Regular" iterable object from the chapter <info:iterable> look like this:
+
+```js run
+let range = {
+  from: 1,
+  to: 5,
+
+  // for..of calls this method once in the very beginning
+*!*
+  [Symbol.iterator]() {
+*/!*
+    // ...it returns the iterator object:
+    // onward, for..of works only with that object, asking it for next values
+    return {
+      current: this.from,
+      last: this.to,
+
+      // next() is called on each iteration by the for..of loop
+*!*
+      next() { // (2)
+        // it should return the value as an object {done:.., value :...}
+*/!*
+        if (this.current <= this.last) {
+          return { done: false, value: this.current++ };
+        } else {
+          return { done: true };
+        }
+      }
+    };
+  }
+};
+
+for(let value of range) {
+  alert(value); // 1 then 2, then 3, then 4, then 5
+}
+```
+
+If necessary, please refer to the [chapter about iterables](info:iterable) for details about regular iterators.
+
+To make the object iterable asynchronously:
+1. We need to use `Symbol.asyncIterator` instead of `Symbol.iterator`.
+2. `next()` should return a promise.
+3. To iterate over such an object, we should use `for await (let item of iterable)` loop.
+
+Let's make an iterable `range` object, like the one before, but now it will return values asynchronously, one per second:
+
+```js run
+let range = {
+  from: 1,
+  to: 5,
+
+  // for await..of calls this method once in the very beginning
+*!*
+  [Symbol.asyncIterator]() { // (1)
+*/!*
+    // ...it returns the iterator object:
+    // onward, for await..of works only with that object, asking it for next values
+    return {
+      current: this.from,
+      last: this.to,
+
+      // next() is called on each iteration by the for..of loop
+*!*
+      async next() { // (2)
+        // it should return the value as an object {done:.., value :...}
+        // (automatically wrapped into a promise by async)
+*/!*
+
+        // can use await inside, do async stuff:
+        await new Promise(resolve => setTimeout(resolve, 1000)); // (3)
+
+        if (this.current <= this.last) {
+          return { done: false, value: this.current++ };
+        } else {
+          return { done: true };
+        }
+      }
+    };
+  }
+};
+
+(async () => {
+
+*!*
+  for await (let value of range) { // (4)
+    alert(value); // 1,2,3,4,5
+  }
+*/!*
+
+})()
+```
+
+As we can see, the components are similar to regular iterators:
+
+1. To make an object asynchronously iterable, it must have a method `Symbol.asyncIterator` `(1)`.
+2. It must return the object with `next()` method returning a promise `(2)`.
+3. The `next()` method doesn't have to be `async`, it may be a regular method returning a promise, but `async` allows to use `await` inside. Here we just delay for a second `(3)`.
+4. To iterate, we use `for await(let value of range)` `(4)`, namely add "await" after "for". It calls `range[Symbol.asyncIterator]()` once, and then its `next()` for values.
+
+Here's a small cheatsheet:
+
+|       | Iterators | Async iterators |
+|-------|-----------|-----------------|
+| Object method to provide iteraterable | `Symbol.iterator` | `Symbol.asyncIterator` |
+| `next()` return value is              | any value         | `Promise`  |
+| to loop, use                          | `for..of`         | `for await..of` |
+
+
+````warn header="The spread operator doesn't work asynchronously"
+Features that require regular, synchronous iterators, don't work with asynchronous ones.
+
+For instance, a spread operator won't work:
+```js
+alert( [...range] ); // Error, no Symbol.iterator
+```
+
+That's natural, as it expects to find `Symbol.iterator`, same as `for..of` without `await`.
+````
+
+## Async generators
+
+JavaScript also provides generators, that are also iterable.
+
+Let's recall a sequence generator from the chapter [](info:generators). It generates a sequence of values from `start` to `end` (could be anything else):
+
+```js run
+function* generateSequence(start, end) {
+  for (let i = start; i <= end; i++) {
+    yield i;
+  }
+}
+
+for(let value of generateSequence(1, 5)) {
+  alert(value); // 1, then 2, then 3, then 4, then 5
+}
+```
+
+
+Normally, we can't use `await` in generators. All values must come synchronously: there's no place for delay in `for..of`.
+
+But what if we need to use `await` in the generator body? To perform network requests, for instance.
+
+No problem, just prepend it with `async`, like this:
+
+```js run
+*!*async*/!* function* generateSequence(start, end) {
+
+  for (let i = start; i <= end; i++) {
+
+*!*
+    // yay, can use await!
+    await new Promise(resolve => setTimeout(resolve, 1000));
+*/!*
+
+    yield i;
+  }
+
+}
+
+(async () => {
+
+  let generator = generateSequence(1, 5);
+  for *!*await*/!* (let value of generator) {
+    alert(value); // 1, then 2, then 3, then 4, then 5
+  }
+
+})();
+```
+
+Now we have an the async generator, iteratable with `for await...of`.
+
+It's indeed very simple. We add the `async` keyword, and the generator now can use `await` inside of it, rely on promises and other async functions.
+
+Technically, another the difference of an async generator is that its `generator.next()` method is now asynchronous also, it returns promises.
+
+Instead of `result = generator.next()` for a regular, non-async generator, values can be obtained like this:
+
+```js
+result = await generator.next(); // result = {value: ..., done: true/false}
+```
+
+## Iterables via async generators
+
+When we'd like to make an object iterable, we should add `Symbol.iterator` to it.
+
+```js
+let range = {
+  from: 1,
+  to: 5,
+*!*
+  [Symbol.iterator]() { ...return object with next to make range iterable...  }
+*/!*
+}
+```
+
+A common practice for `Symbol.iterator` is to return a generator, rather than a plain object with `next` as in the example before.
+
+Let's recall an example from the chapter [](info:generators):
+
+```js run
+let range = {
+  from: 1,
+  to: 5,
+
+  *[Symbol.iterator]() { // a shorthand for [Symbol.iterator]: function*()
+    for(let value = this.from; value <= this.to; value++) {
+      yield value;
+    }
+  }
+};
+
+for(let value of range) {
+  alert(value); // 1, then 2, then 3, then 4, then 5
+}
+```
+
+Here a custom object `range` is iterable, and the generator `*[Symbol.iterator]` implements the logic for listing values.
+
+If we'd like to add async actions into the generator, then we should replace `Symbol.iterator` with async `Symbol.asyncIterator`:
+
+```js run
+let range = {
+  from: 1,
+  to: 5,
+
+*!*
+  async *[Symbol.asyncIterator]() { // same as [Symbol.asyncIterator]: async function*()
+*/!*
+    for(let value = this.from; value <= this.to; value++) {
+
+      // make a pause between values, wait for something  
+      await new Promise(resolve => setTimeout(resolve, 1000));
+
+      yield value;
+    }
+  }
+};
+
+(async () => {
+
+  for *!*await*/!* (let value of range) {
+    alert(value); // 1, then 2, then 3, then 4, then 5
+  }
+
+})();
+```
+
+Now values come with a delay of 1 second between them.
+
+## Real-life example
+
+So far we've seen simple examples, to gain basic understanding. Now let's review a real-life use case.
+
+There are many online APIs that deliver paginated data. For instance, when we need a list of users, then we can fetch it page-by-page: a request returns a pre-defined count (e.g. 100 users), and provides an URL to the next page.
+
+The pattern is very common, it's not about users, but just about anything. For instance, GitHub allows to retrieve commits in the same, paginated fashion:
+
+- We should make a request to URL in the form `https://api.github.com/repos/<repo>/commits`.
+- It responds with a JSON of 30 commits, and also provides a link to the next page in the `Link` header.
+- Then we can use that link for the next request, to get more commits, and so on.
+
+What we'd like to have is an iterable source of commits, so that we could use it like this:
+
+```js
+let repo = 'javascript-tutorial/en.javascript.info'; // GitHub repository to get commits from
+
+for await (let commit of fetchCommits(repo)) {
+  // process commit
+}
+```
+
+We'd like `fetchCommits` to get commits for us, making requests whenever needed. And let it care about all pagination stuff, for us it'll be a simple `for await..of`.
+
+With async generators that's pretty easy to implement:
+
+```js
+async function* fetchCommits(repo) {
+  let url = `https://api.github.com/repos/${repo}/commits`;
+
+  while (url) {
+    const response = await fetch(url, { // (1)
+      headers: {'User-Agent': 'Our script'}, // github requires user-agent header
+    });
+
+    const body = await response.json(); // (2) parses response as JSON (array of commits)
+
+    // (3) the URL of the next page is in the headers, extract it
+    let nextPage = response.headers.get('Link').match(/<(.*?)>; rel="next"/);
+    nextPage = nextPage && nextPage[1];
+
+    url = nextPage;
+
+    for(let commit of body) { // (4) yield commits one by one, until the page ends
+      yield commit;
+    }
+  }
+}
+```
+
+1. We use the browser `fetch` method to download from a remote URL. It allows to supply authorization and other headers if needed, here GitHub requires `User-Agent`.
+2. The fetch result is parsed as JSON, that's again a `fetch`-specific method.
+3. We can get the next page URL from the `Link` header of the response. It has a special format, so we use a regexp for that. The next page URL may look like this: `https://api.github.com/repositories/93253246/commits?page=2`, it's generatd by GitHub itself.
+4. Then we yield all commits received, and when they finish -- the next `while(url)` iteration will trigger, making one more request.
+
+An example of use (shows commit authors in console):
+
+```js run
+(async () => {
+
+  let count = 0;
+
+  for await (const commit of fetchCommits('javascript-tutorial/en.javascript.info')) {
+
+    console.log(commit.author.login);
+
+    if (++count == 100) { // let's stop at 100 commits
+      break;
+    }
+  }
+
+})();
+```
+
+That's just what we wanted. The internal pagination mechanics is invisible from the outside. For us it's just an async generator that returns commits.
+
+## Summary
+
+Regular iterators and generators work fine with the data that doesn't take time to generate.
+
+When we expect the data to come asynchronously, with delays, their async counterparts can be used, and `for await..of` instead of `for..of`.
+
+Syntax differences between async and regular iterators:
+
+|       | Iterators | Async iterators |
+|-------|-----------|-----------------|
+| Object method to provide iteraterable | `Symbol.iterator` | `Symbol.asyncIterator` |
+| `next()` return value is              | any value         | `Promise`  |
+
+Syntax differences between async and regular generators:
+
+|       | Generators | Async generators |
+|-------|-----------|-----------------|
+| Declaration | `function*` | `async function*` |
+| `generator.next()` returns              | `{value:…, done: true/false}`         | `Promise` that resolves to `{value:…, done: true/false}`  |
+
+In web-development we often meet streams of data, when it flows chunk-by-chunk. For instance, downloading or uploading a big file.
+
+We could use async generators to process such data, but there's also another API called Streams, that may be more convenient, as it provides special interfaces to transform the data and to pass it from one stream to another (e.g. download from one place and immediately send elsewhere). But they are also more complex.
+
+Streams API not a part of JavaScript language standard. Streams and async generators complement each other, both are great ways to handle async data flows.
diff --git a/1-js/12-generators-iterators/2-async-iterators-generators/head.html b/1-js/12-generators-iterators/2-async-iterators-generators/head.html
new file mode 100644
index 000000000..74d66a8b8
--- /dev/null
+++ b/1-js/12-generators-iterators/2-async-iterators-generators/head.html
@@ -0,0 +1,24 @@
+<script>
+  async function* fetchCommits(repo) {
+    let url = `https://api.github.com/repos/${repo}/commits`;
+
+    while (url) {
+      const response = await fetch(url, {
+        headers: {'User-Agent': 'Our script'}, // github requires user-agent header
+      });
+
+      const body = await response.json(); // parses response as JSON (array of commits)
+
+      // the URL of the next page is in the headers, extract it
+      let nextPage = response.headers.get('Link').match(/<(.*?)>; rel="next"/);
+      nextPage = nextPage && nextPage[1];
+
+      url = nextPage;
+
+      // yield commits one by one, when they finish - fetch a new page url
+      for(let commit of body) {
+        yield commit;
+      }
+    }
+  }
+</script>
diff --git a/1-js/12-generators-iterators/index.md b/1-js/12-generators-iterators/index.md
new file mode 100644
index 000000000..ccc909d1a
--- /dev/null
+++ b/1-js/12-generators-iterators/index.md
@@ -0,0 +1,2 @@
+
+# Generators, advanced iteration
diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
new file mode 100644
index 000000000..ad4f21068
--- /dev/null
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -0,0 +1,375 @@
+
+# Modules, introduction
+
+As our application grows bigger, we want to split it into multiple files, so called 'modules'.
+A module usually contains a class or a library of useful functions.
+
+For a long time, JavaScript existed without a language-level module syntax. That wasn't a problem, because initially scripts were small and simple. So there was no need.
+
+But eventually scripts became more and more complex, so the community invented a variety of ways to organize code into modules.
+
+For instance:
+
+- [AMD](https://en.wikipedia.org/wiki/Asynchronous_module_definition) -- one of the most ancient module systems, initially implemented by the library [require.js](http://requirejs.org/).
+- [CommonJS](http://wiki.commonjs.org/wiki/Modules/1.1) -- the module system created for Node.js server.
+- [UMD](https://github.com/umdjs/umd) -- one more module system, suggested as a universal one, compatible with AMD and CommonJS.
+
+Now all these slowly become a part of history, but we still can find them in old scripts. The language-level module system appeared in the standard in 2015, gradually evolved since then, and is now supported by all major browsers and in Node.js.
+
+## What is a module?
+
+A module is just a file, a single script, as simple as that.
+
+Directives `export` and `import` allow to interchange functionality between modules:
+
+- `export` keyword labels variables and functions that should be accessible from outside the file.
+- `import` allows to import functionality from other modules.
+
+For instance, if we have a file `sayHi.js` exporting a function:
+
+```js
+// 📁 sayHi.js
+export function sayHi(user) {
+  alert(`Hello, ${user}!`);
+}
+```
+
+...Then another file may import and use it:
+
+```js
+// 📁 main.js
+import {sayHi} from './sayHi.js';
+
+alert(sayHi); // function...
+sayHi('John'); // Hello, John!
+```
+
+In this tutorial we concentrate on the language itself, but we use browser as the demo environment, so let's see how modules work in the browser.
+
+To use modules, we must set the attribute `<script type="module">`, like this:
+
+[codetabs src="say" height="140" current="index.html"]
+
+The browser automatically fetches and evaluates imports, then runs the script.
+
+## Core module features
+
+What's different in modules, compared to "regular" scripts?
+
+There are core features, valid both for browser and server-side JavaScript.
+
+### Always "use strict"
+
+Modules always `use strict`. E.g. assigning to an undeclared variable will give an error.
+
+```html run
+<script type="module">
+  a = 5; // error
+</script>
+```
+
+Here we can see it in the browser, but the same is true for any module.
+
+### Module-level scope
+
+Each module has its own top-level scope. In other words, top-level variables and functions from a module are not seen in other scripts.
+
+In the example below, two scripts are imported, and `hello.js` tries to use `user` variable declared in `user.js`, and fails:
+
+[codetabs src="scopes" height="140" current="index.html"]
+
+Modules are expected to `export` what they want to be accessible from outside and `import` what they need.
+
+So we should import `user.js` directly into `hello.js` instead of `index.html`.
+
+That's the correct variant:
+
+[codetabs src="scopes-working" height="140" current="hello.js"]
+
+In the browser, independant top-level scope also exists for each `<script type="module">`:
+
+```html run
+<script type="module">
+  // The variable is only visible in this module script
+  let user = "John";
+</script>
+
+<script type="module">
+  *!*
+  alert(user); // Error: user is not defined
+  */!*
+</script>
+```
+
+If we really need to make a "global" in-browser variable, we can explicitly assign it to `window` and access as `window.user`. But that's an exception requiring a good reason.
+
+### A module code is evaluated only the first time when imported
+
+If the same module is imported into multiple other places, its code is executed only the first time, then exports are given to all importers.
+
+That has important consequences. Let's see that on examples.
+
+First, if executing a module code brings side-effects, like showing a message, then importing it multiple times will trigger it only once -- the first time:
+
+```js
+// 📁 alert.js
+alert("Module is evaluated!");
+```
+
+```js
+// Import the same module from different files
+
+// 📁 1.js
+import `./alert.js`; // Module is evaluated!
+
+// 📁 2.js
+import `./alert.js`; // (nothing)
+```
+
+In practice, top-level module code is mostly used for initialization. We create data structures, pre-fill them, and if we want something to be reusable -- export it.
+
+Now, a more advanced example.
+
+Let's say, a module exports an object:
+
+```js
+// 📁 admin.js
+export let admin = {
+  name: "John"
+};
+```
+
+If this module is imported from multiple files, the module is only evaluated the first time, `admin` object is created, and then passed to all further importers.
+
+All importers get exactly the one and only `admin` object:
+
+```js
+// 📁 1.js
+import {admin} from './admin.js';
+admin.name = "Pete";
+
+// 📁 2.js
+import {admin} from './admin.js';
+alert(admin.name); // Pete
+
+*!*
+// Both 1.js and 2.js imported the same object
+// Changes made in 1.js are visible in 2.js
+*/!*
+```
+
+So, let's reiterate -- the module is executed only once. Exports are generated, and then they are shared between importers, so if something changes the `admin` object, other modules will see that .
+
+Such behavior is great for modules that require configuration. We can set required properties on the first import, and then in further imports it's ready.
+
+For instance, `admin.js` module may provide certain functionality, but expect the credentials to come into the `admin` object from outside:
+
+```js
+// 📁 admin.js
+export let admin = { };
+
+export function sayHi() {
+  alert(`Ready to serve, ${admin.name}!`);
+}
+```
+
+Now, in `init.js`, the first script of our app, we set `admin.name`. Then everyone will see it, including calls made from inside `admin.js` itself:
+
+```js
+// 📁 init.js
+import {admin} from './admin.js';
+admin.name = "Pete";
+```
+
+```js
+// 📁 other.js
+import {admin, sayHi} from './admin.js';
+
+alert(admin.name); // *!*Pete*/!*
+
+sayHi(); // Ready to serve, *!*Pete*/!*!
+```
+
+### import.meta
+
+The object `import.meta` contains the information about the current module.
+
+Its content depends on the environment. In the browser, it contains the url of the script, or a current webpage url if inside HTML:
+
+```html run height=0
+<script type="module">
+  alert(import.meta.url); // script url (url of the html page for an inline script)
+</script>
+```
+
+### Top-level "this" is undefined
+
+That's kind of a minor feature, but for completeness we should mention it.
+
+In a module, top-level `this` is undefined, as opposed to a global object in non-module scripts:
+
+```html run height=0
+<script>
+  alert(this); // window
+</script>
+
+<script type="module">
+  alert(this); // undefined
+</script>
+```
+
+## Browser-specific features
+
+There are also several browser-specific differences of scripts with `type="module"` compared to regular ones.
+
+You may want skip those for now if you're reading for the first time, or if you don't use JavaScript in a browser.
+
+### Module scripts are deferred
+
+Module scripts are *always* deferred, same effect as `defer` attribute (described in the chapter [](info:script-async-defer)), for both external and inline scripts.
+
+In other words:
+- external module scripts `<script type="module" src="...">` don't block HTML processing.
+- module scripts wait until the HTML document is fully ready.
+- relative order is maintained: scripts that go first in the document, execute first.
+
+As a side-effect, module scripts always see HTML elements below them.
+
+For instance:
+
+```html run
+<script type="module">
+*!*
+  alert(typeof button); // object: the script can 'see' the button below
+*/!*
+  // as modules are deferred, the script runs after the whole page is loaded
+</script>
+
+<script>
+*!*
+  alert(typeof button); // Error: button is undefined, the script can't see elements below
+*/!*
+  // regular scripts run immediately, before the rest of the page is processed
+</script>
+
+<button id="button">Button</button>
+```
+
+Please note: the second script actually works before the first! So we'll see `undefined` first, and then `object`.
+
+That's because modules are deferred, so way wait for the document to be processed. The regular scripts runs immediately, so we saw its output first.
+
+When using modules, we should be aware that HTML-document can show up before the JavaScript application is ready. Some functionality may not work yet. We should put transparent overlays or "loading indicators", or otherwise ensure that the visitor won't be confused because of it.
+
+### Async works on inline scripts
+
+Async attribute `<script async type="module">` is allowed on both inline and external scripts. Async scripts run immediately when imported modules are processed, independantly of other scripts or the HTML document.
+
+For example, the script below has `async`, so it doesn't wait for anyone.
+
+It performs the import (fetches `./analytics.js`) and runs when ready, even if HTML document is not finished yet, or if other scripts are still pending.
+
+That's good for functionality that doesn't depend on anything, like counters, ads, document-level event listeners.
+
+```html
+<!-- all dependencies are fetched (analytics.js), and the script runs -->
+<!-- doesn't wait for the document or other <script> tags -->
+<script *!*async*/!* type="module">
+  import {counter} from './analytics.js';
+
+  counter.count();
+</script>
+```
+
+### External scripts
+
+There are two notable differences of external module scripts:
+
+1. External scripts with same `src` run only once:
+    ```html
+    <!-- the script my.js is fetched and executed only once -->
+    <script type="module" src="my.js"></script>
+    <script type="module" src="my.js"></script>
+    ```
+
+2. External scripts that are fetched from another domain require [CORS](mdn:Web/HTTP/CORS) headers. In other words, if a module script is fetched from another domain, the remote server must supply a header `Access-Control-Allow-Origin: *` (may use fetching domain instead of `*`) to indicate that the fetch is allowed.
+    ```html
+    <!-- another-site.com must supply Access-Control-Allow-Origin -->
+    <!-- otherwise, the script won't execute -->
+    <script type="module" src="*!*http://another-site.com/their.js*/!*"></script>
+    ```
+
+    That ensures better security by default.
+
+### No bare modules allowed
+
+In the browser, in scripts (not in HTML), `import` must get either a relative or absolute URL. So-called "bare" modules, without a path, are not allowed.
+
+For instance, this `import` is invalid:
+```js
+import {sayHi} from 'sayHi'; // Error, "bare" module
+// must be './sayHi.js' or wherever the module is
+```
+
+Certain environments, like Node.js or bundle tools allow bare modules, as they have own ways for finding modules and hooks to fine-tune them. But browsers do not support bare modules yet.
+
+### Compatibility, "nomodule"
+
+Old browsers do not understand `type="module"`. Scripts of the unknown type are just ignored. For them, it's possible to provide a fallback using `nomodule` attribute:
+
+```html run
+<script type="module">
+  alert("Runs in modern browsers");
+</script>
+
+<script nomodule>
+  alert("Modern browsers know both type=module and nomodule, so skip this")
+  alert("Old browsers ignore script with unknown type=module, but execute this.");
+</script>
+```
+
+If we use bundle tools, then as modules are bundled together, their `import/export` statements are replaced by special bundler calls, so the resulting build does not require `type="module"`, and we can put it into a regular script:
+
+```html
+<!-- Assuming we got bundle.js from a tool like Webpack -->
+<script src="bundle.js"></script>
+```
+
+## Build tools
+
+In real-life, browser modules are rarely used in their "raw" form. Usually, we bundle them together with a special tool such as [Webpack](https://webpack.js.org/) and deploy to the production server.
+
+One of the benefits of using bundlers -- they give more control over how modules are resolved, allowing bare modules and much more, like CSS/HTML modules.
+
+Build tools do the following:
+
+1. Take a "main" module, the one intended to be put in `<script type="module">` in HTML.
+2. Analyze its dependencies: imports and then imports of imports etc.
+3. Build a single file with all modules (or multiple files, that's tunable), replacing native `import` calls with bundler functions, so that it works. "Special" module types like HTML/CSS modules are also supported.
+4. In the process, other transforms and optimizations may be applied:
+    - Unreachable code removed.
+    - Unused exports removed ("tree-shaking").
+    - Development-specific statements like `console` and `debugger` removed.
+    - Modern, bleeding-edge JavaScript syntax may be transformed to older one with similar functionality using [Babel](https://babeljs.io/).
+    - The resulting file is minified (spaces removed, variables replaced with shorter named etc).
+
+That said, native modules are also usable. So we won't be using Webpack here: you can configure it later.
+
+## Summary
+
+To summarize, the core concepts are:
+
+1. A module is a file. To make `import/export` work, browsers need `<script type="module">`, that implies several differences:
+    - Deferred by default.
+    - Async works on inline scripts.
+    - External scripts need CORS headers.
+    - Duplicate external scripts are ignored.
+2. Modules have their own, local top-level scope and interchange functionality via `import/export`.
+3. Modules always `use strict`.
+4. Module code is executed only once. Exports are created once and shared between importers.
+
+So, generally, when we use modules, each module implements the functionality and exports it. Then we use `import` to directly import it where it's needed. Browser loads and evaluates the scripts automatically.
+
+In production, people often use bundlers such as [Webpack](https://webpack.js.org) to bundle modules together for performance and other reasons.
+
+In the next chapter we'll see more examples of modules, and how things can be exported/imported.
diff --git a/1-js/13-modules/01-modules-intro/say.view/index.html b/1-js/13-modules/01-modules-intro/say.view/index.html
new file mode 100644
index 000000000..9a0429cf5
--- /dev/null
+++ b/1-js/13-modules/01-modules-intro/say.view/index.html
@@ -0,0 +1,6 @@
+<!doctype html>
+<script type="module">
+  import {sayHi} from './say.js';
+
+  document.body.innerHTML = sayHi('John');
+</script>
diff --git a/1-js/13-modules/01-modules-intro/say.view/say.js b/1-js/13-modules/01-modules-intro/say.view/say.js
new file mode 100644
index 000000000..198a3be6d
--- /dev/null
+++ b/1-js/13-modules/01-modules-intro/say.view/say.js
@@ -0,0 +1,3 @@
+export function sayHi(user) {
+  return `Hello, ${user}!`;
+}
diff --git a/1-js/13-modules/01-modules-intro/scopes-working.view/hello.js b/1-js/13-modules/01-modules-intro/scopes-working.view/hello.js
new file mode 100644
index 000000000..6c087ea81
--- /dev/null
+++ b/1-js/13-modules/01-modules-intro/scopes-working.view/hello.js
@@ -0,0 +1,3 @@
+import {user} from './user.js';
+
+document.body.innerHTML = user; // John
diff --git a/1-js/13-modules/01-modules-intro/scopes-working.view/index.html b/1-js/13-modules/01-modules-intro/scopes-working.view/index.html
new file mode 100644
index 000000000..b78f75912
--- /dev/null
+++ b/1-js/13-modules/01-modules-intro/scopes-working.view/index.html
@@ -0,0 +1,2 @@
+<!doctype html>
+<script type="module" src="hello.js"></script>
diff --git a/1-js/13-modules/01-modules-intro/scopes-working.view/user.js b/1-js/13-modules/01-modules-intro/scopes-working.view/user.js
new file mode 100644
index 000000000..d289329c6
--- /dev/null
+++ b/1-js/13-modules/01-modules-intro/scopes-working.view/user.js
@@ -0,0 +1 @@
+export let user = "John";
diff --git a/1-js/13-modules/01-modules-intro/scopes.view/hello.js b/1-js/13-modules/01-modules-intro/scopes.view/hello.js
new file mode 100644
index 000000000..714aafa1f
--- /dev/null
+++ b/1-js/13-modules/01-modules-intro/scopes.view/hello.js
@@ -0,0 +1 @@
+alert(user); // no such variable (each module has independent variables)
diff --git a/1-js/13-modules/01-modules-intro/scopes.view/index.html b/1-js/13-modules/01-modules-intro/scopes.view/index.html
new file mode 100644
index 000000000..a87e96fdf
--- /dev/null
+++ b/1-js/13-modules/01-modules-intro/scopes.view/index.html
@@ -0,0 +1,3 @@
+<!doctype html>
+<script type="module" src="user.js"></script>
+<script type="module" src="hello.js"></script>
diff --git a/1-js/13-modules/01-modules-intro/scopes.view/user.js b/1-js/13-modules/01-modules-intro/scopes.view/user.js
new file mode 100644
index 000000000..12ec850d9
--- /dev/null
+++ b/1-js/13-modules/01-modules-intro/scopes.view/user.js
@@ -0,0 +1 @@
+let user = "John";
diff --git a/1-js/13-modules/02-import-export/article.md b/1-js/13-modules/02-import-export/article.md
new file mode 100644
index 000000000..bf31065bc
--- /dev/null
+++ b/1-js/13-modules/02-import-export/article.md
@@ -0,0 +1,438 @@
+
+# Export and Import
+
+Export and import directives are very versatile.
+
+In the previous chapter we saw a simple use, now let's explore more examples.
+
+## Export before declarations
+
+We can label any declaration as exported by placing `export` before it, be it a variable, function or a class.
+
+For instance, here all exports are valid:
+
+```js
+// export an array
+*!*export*/!* let months = ['Jan', 'Feb', 'Mar','Apr', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+// export a constant
+*!*export*/!* const MODULES_BECAME_STANDARD_YEAR = 2015;
+
+// export a class
+*!*export*/!* class User {
+  constructor(name) {
+    this.name = name;
+  }
+}
+```
+
+````smart header="No semicolons after export class/function"
+Please note that `export` before a class or a function does not make it a [function expression](info:function-expressions-arrows). It's still a function declaration, albeit exported.
+
+Most JavaScript style guides recommend semicolons after statements, but not after function and class declarations.
+
+That's why there should be no semicolons at the end of `export class` and `export function`.
+
+```js
+export function sayHi(user) {
+  alert(`Hello, ${user}!`);
+} *!* // no ; at the end */!*
+```
+
+````
+
+## Export apart from declarations
+
+Also, we can put `export` separately.
+
+Here we first declare, and then export:
+
+```js  
+// 📁 say.js
+function sayHi(user) {
+  alert(`Hello, ${user}!`);
+}
+
+function sayBye(user) {
+  alert(`Bye, ${user}!`);
+}
+
+*!*
+export {sayHi, sayBye}; // a list of exported variables
+*/!*
+```
+
+...Or, technically we could put `export` above functions as well.
+
+## Import *
+
+Usually, we put a list of what to import into `import {...}`, like this:
+
+```js
+// 📁 main.js
+*!*
+import {sayHi, sayBye} from './say.js';
+*/!*
+
+sayHi('John'); // Hello, John!
+sayBye('John'); // Bye, John!
+```
+
+But if the list is long, we can import everything as an object using `import * as <obj>`, for instance:
+
+```js
+// 📁 main.js
+*!*
+import * as say from './say.js';
+*/!*
+
+say.sayHi('John');
+say.sayBye('John');
+```
+
+At first sight, "import everything" seems such a cool thing, short to write, why should we ever explicitly list what we need to import?
+
+Well, there are few reasons.
+
+1. Modern build tools ([webpack](http://webpack.github.io) and others) bundle modules together and optimize them to speedup loading and remove unused stuff.
+
+    Let's say, we added a 3rd-party library `lib.js` to our project with many functions:
+    ```js
+    // 📁 lib.js
+    export function sayHi() { ... }
+    export function sayBye() { ... }
+    export function becomeSilent() { ... }
+    ```
+
+    Now if we in fact need only one of them in our project:
+    ```js
+    // 📁 main.js
+    import {sayHi} from './lib.js';
+    ```
+    ...Then the optimizer will automatically detect it and totally remove the other functions from the bundled code, thus making the build smaller. That is called "tree-shaking".
+
+2. Explicitly listing what to import gives shorter names: `sayHi()` instead of `lib.sayHi()`.
+3. Explicit imports give better overview of the code structure: what is used and where. It makes code support and refactoring easier.
+
+## Import "as"
+
+We can also use `as` to import under different names.
+
+For instance, let's import `sayHi` into the local variable `hi` for brevity, and same for `sayBye`:
+
+```js
+// 📁 main.js
+*!*
+import {sayHi as hi, sayBye as bye} from './say.js';
+*/!*
+
+hi('John'); // Hello, John!
+bye('John'); // Bye, John!
+```
+
+## Export "as"
+
+The similar syntax exists for `export`.
+
+Let's export functions as `hi` and `bye`:
+
+```js
+// 📁 say.js
+...
+export {sayHi as hi, sayBye as bye};
+```
+
+Now `hi` and `bye` are official names for outsiders:
+
+```js
+// 📁 main.js
+import * as say from './say.js';
+
+say.hi('John'); // Hello, John!
+say.bye('John'); // Bye, John!
+```
+
+## export default
+
+So far, we've seen how to import/export multiple things, optionally "as" other names.
+
+In practice, modules contain either:
+- A library, pack of functions, like `lib.js`.
+- Or an entity, like `class User` is described in `user.js`, the whole module has only this class.
+
+Mostly, the second approach is preferred, so that every "thing" resides in its own module.
+
+Naturally, that requires a lot of files, as everything wants its own module, but that's not a problem at all. Actually, code navigation becomes easier, if files are well-named and structured into folders.
+
+Modules provide special `export default` syntax to make "one thing per module" way look better.
+
+It requires following `export` and `import` statements:
+
+1. Put `export default` before the "main export" of the module.
+2. Call `import` without curly braces.
+
+For instance, here `user.js` exports `class User`:
+
+```js
+// 📁 user.js
+export *!*default*/!* class User { // just add "default"
+  constructor(name) {
+    this.name = name;
+  }
+}
+```
+
+...And `main.js` imports it:
+
+```js
+// 📁 main.js
+import *!*User*/!* from './user.js'; // not {User}, just User
+
+new User('John');
+```
+
+Imports without curly braces look nicer. A common mistake when starting to use modules is to forget curly braces at all. So, remember, `import` needs curly braces for named imports and doesn't need them for the default one.
+
+| Named export | Default export |
+|--------------|----------------|
+| `export class User {...}` | `export default class User {...}` |
+| `import {User} from ...` | `import User from ...`|
+
+Naturally, there may be only one "default" export per file.
+
+We may have both default and named exports in a single module, but in practice people usually don't mix them. A module has either named exports or the default one.
+
+**Another thing to note is that named exports must (naturally) have a name, while `export default` may be anonymous.**
+
+For instance, these are all perfectly valid default exports:
+
+```js
+export default class { // no class name
+  constructor() { ... }
+}
+
+export default function(user) { // no function name
+  alert(`Hello, ${user}!`);
+}
+
+// export a single value, without making a variable
+export default ['Jan', 'Feb', 'Mar','Apr', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+```
+
+That's fine, because `export default` is only one per file, so `import` always knows what to import.
+ Contrary to that, omitting a name for named imports would be an error:
+
+```js
+export class { // Error! (non-default export needs a name)
+  constructor() {}
+}
+```     
+
+### "Default" alias
+
+The "default" word is a kind of "alias" for the default export, for scenarios when we need to reference it somehow.
+
+For example, if we already have a function declared, that's how to `export default` it:
+
+```js
+function sayHi(user) {
+  alert(`Hello, ${user}!`);
+}
+
+export {sayHi as default}; // same as if we added "export default" before the function
+```
+
+Or, let's say a module `user.js` exports one main "default" thing and a few named ones (rarely the case, but happens):
+
+```js
+// 📁 user.js
+export default class User {
+  constructor(name) {
+    this.name = name;
+  }
+}
+
+export function sayHi(user) {
+  alert(`Hello, ${user}!`);
+}
+```
+
+Here's how to import the default export along with a named one:
+
+```js
+// 📁 main.js
+import {*!*default as User*/!*, sayHi} from './user.js';
+
+new User('John');
+```
+
+Or, if we consider importing `*` as an object, then the `default` property is exactly the default export:
+
+```js
+// 📁 main.js
+import * as user from './user.js';
+
+let User = user.default;
+new User('John');
+```
+
+
+### Should I use default exports?
+
+One should be careful about using default exports, because they are somewhat more different to maintain.
+
+Named exports are explicit. They exactly name what they import, so we have that information from them, that's a good thing.
+
+Also, named exports enforce us to use exactly the right name to import:
+
+```js
+import {User} from './user.js';
+```
+
+For default exports, we need to create a name on our own:
+
+```js
+import MyUser from './user.js'; // could be import Anything..., and it'll work
+```
+
+So, there's a little bit more freedom that can be abused, so that team members may use different names for the same thing.
+
+Usually, to avoid that and keep the code consistent, there's a rule that imported variables should correspond to file names, e.g:
+
+```js
+import User from './user.js';
+import LoginForm from './loginForm.js';
+import func from '/path/to/func.js';
+...
+```
+
+Another solution would be to use named exports everywhere. Even if only a single thing is exported, it's still exported under a name, without `default`.
+
+That also makes re-export (see below) a little bit easier.
+
+## Re-export
+
+"Re-export" syntax `export ... from ...` allows to import things and immediately export them (possibly under another name), like this:
+
+```js
+export {sayHi} from './say.js';
+export {default as User} from './user.js';
+```
+
+What's the point, why that's needed? Let's see a practical use case.
+
+Imagine, we're writing a "package": a folder with a lot of modules, mostly needed internally, with some of the functionality exported outside (tools like NPM allow to publish and distribute packages, but here it doesn't matter).
+
+A directory structure could be like this:
+```
+auth/
+  index.js  
+  user.js
+  helpers.js
+  tests/
+    login.js
+  providers/
+    github.js
+    facebook.js
+    ...
+```
+
+We'd like to expose the package functionality via a single entry point, the "main file" `auth/index.js`, to be used like this:
+
+```js
+import {login, logout} from 'auth/index.js'
+```
+
+The idea is that outsiders, developers who use our package, should not meddle with its internal structure. They should not search for files inside our package folder. We export only what's necessary in `auth/index.js` and keep the rest hidden from prying eyes.
+
+Now, as the actual exported functionality is scattered among the package, we can gather and "re-export" it in `auth/index.js`:
+
+```js
+// 📁 auth/index.js
+import {login, logout} from './helpers.js';
+export {login, logout};
+
+import User from './user.js';
+export {User};
+
+import Github from './providers/github.js';
+export {Github};
+...
+```
+
+"Re-exporting" is just a shorter notation for that:
+
+```js
+// 📁 auth/index.js
+export {login, logout} from './helpers.js';
+// or, to re-export all helpers, we could use:
+// export * from './helpers.js';
+
+export {default as User} from './user.js';
+
+export {default as Github} from './providers/github.js';
+...
+```
+
+````warn header="Re-exporting default is tricky"
+Please note: `export User from './user.js'` won't work. It's actually a syntax error. To re-export the default export, we must mention it explicitly `{default as ...}`, like in the example above.
+
+Also, there's another oddity: `export * from './user.js'` re-exports only named exports, exluding the default one. Once again, we need to mention it explicitly.
+
+For instance, to re-export everything, two statements will be necessary:
+```js
+export * from './module.js'; // to re-export named exports
+export {default} from './module.js'; // to re-export default
+```
+
+The default should be mentioned explicitly only when re-exporting: `import * as obj` works fine. It imports the default export as `obj.default`. So there's a slight asymmetry between import and export constructs here.
+````
+
+## Summary
+
+There are following types of `export`:
+
+- Before declaration:
+  - `export [default] class/function/variable ...`
+- Standalone:
+  - `export {x [as y], ...}`.
+- Re-export:
+  - `export {x [as y], ...} from "mod"`
+  - `export * from "mod"` (doesn't re-export default).
+  - `export {default [as y]} from "mod"` (re-export default).
+
+Import:
+
+- Named exports from module:
+  - `import {x [as y], ...} from "mod"`
+- Default export:  
+  - `import x from "mod"`
+  - `import {default as x} from "mod"`
+- Everything:
+  - `import * as obj from "mod"`
+- Only fetch/evalute the module, don't import:
+  - `import "mod"`
+
+We can put import/export statements below or after other code, that doesn't matter.
+
+So this is technically fine:
+```js
+sayHi();
+
+import {sayHi} from './say.js'; // import at the end of the file
+```
+
+In practice imports are usually at the start of the file, but that's only for better convenience.
+
+**Please note that import/export statements don't work if inside `{...}`.**
+
+A conditional import, like this, won't work:
+```js
+if (something) {
+  import {sayHi} from "./say.js"; // Error: import must be at top level
+}
+```
+
+...But what if we really need to import something conditionally? Or at the right time? Like, load a module upon request, when it's really needed?
+
+We'll see dynamic imports in the next chapter.
diff --git a/1-js/13-modules/03-modules-dynamic-imports/article.md b/1-js/13-modules/03-modules-dynamic-imports/article.md
new file mode 100644
index 000000000..d8de2bcfa
--- /dev/null
+++ b/1-js/13-modules/03-modules-dynamic-imports/article.md
@@ -0,0 +1,54 @@
+
+# Dynamic imports
+
+Export and import statements that we covered in previous chaters are called "static".
+
+That's because they are indeed static. The syntax is very strict.
+
+First, we can't dynamicaly generate any parameters of `import`.
+
+The module path must be a primitive string, can't be a function call. This won't work:
+
+```js
+import ... from *!*getModuleName()*/!*; // Error, only from "string" is allowed
+```
+
+Second, we can't import conditionally or at run-time:
+
+```js
+if(...) {
+  import ...; // Error, not allowed!
+}
+
+{
+  import ...; // Error, we can't put import in any block
+}
+```
+
+That's because, import/export aim to provide a backbone for the code structure. That's a good thing, as code structure can be analyzed, modules can be gathered and bundled together, unused exports can be removed (tree-shaken). That's possible only because everything is fixed.
+
+But how do we import a module dynamically, on-demand?
+
+## The import() function
+
+The `import(module)` function can be called from anywhere. It returns a promise that resolves into a module object.
+
+The usage pattern looks like this:
+
+```js run
+let modulePath = prompt("Module path?");
+
+import(modulePath)
+  .then(obj => <module object>)
+  .catch(err => <loading error, no such module?>)
+```
+
+Or, we could use `let module = await import(modulePath)` if inside an async function.
+
+Like this:
+
+[codetabs src="say" current="index.html"]
+
+So, dynamic imports are very simple to use.
+
+Also, dynamic imports work in regular scripts, they don't require `script type="module"`.
diff --git a/1-js/13-modules/03-modules-dynamic-imports/say.view/index.html b/1-js/13-modules/03-modules-dynamic-imports/say.view/index.html
new file mode 100644
index 000000000..80909cf94
--- /dev/null
+++ b/1-js/13-modules/03-modules-dynamic-imports/say.view/index.html
@@ -0,0 +1,10 @@
+<!doctype html>
+<script>
+  async function load() {
+    let say = await import('./say.js');
+    say.hi(); // Hello!
+    say.bye(); // Bye!
+    say.default(); // Module loaded (export default)!
+  }
+</script>
+<button onclick="load()">Click me</button>
diff --git a/1-js/13-modules/03-modules-dynamic-imports/say.view/say.js b/1-js/13-modules/03-modules-dynamic-imports/say.view/say.js
new file mode 100644
index 000000000..cff234b7c
--- /dev/null
+++ b/1-js/13-modules/03-modules-dynamic-imports/say.view/say.js
@@ -0,0 +1,11 @@
+export function hi() {
+  alert(`Hello`);
+}
+
+export function bye() {
+  alert(`Bye`);
+}
+
+export default function() {
+  alert("Module loaded (export default)!");
+}
diff --git a/1-js/13-modules/index.md b/1-js/13-modules/index.md
new file mode 100644
index 000000000..78fb060e8
--- /dev/null
+++ b/1-js/13-modules/index.md
@@ -0,0 +1,2 @@
+
+# Modules
diff --git a/1-js/plan3.txt b/1-js/plan3.txt
deleted file mode 100644
index 4d553174f..000000000
--- a/1-js/plan3.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-todo:
-
-intl?
-proxy?
-eval?
diff --git a/10-misc/12-mutation-observer/article.md b/10-misc/12-mutation-observer/article.md
new file mode 100644
index 000000000..1045e87a8
--- /dev/null
+++ b/10-misc/12-mutation-observer/article.md
@@ -0,0 +1,249 @@
+
+# Mutation observer
+
+`MutationObserver` is a built-in object that observes a DOM element and fires a callback in case of changes.
+
+We'll first see syntax, and then explore a real-world use case.
+
+## Syntax
+
+`MutationObserver` is easy to use.
+
+First, we create an observer with a callback-function:
+
+```js
+let observer = new MutationObserver(callback);
+```
+
+And then attach it to a DOM node:
+
+```js
+observer.observe(node, config);
+```
+
+`config` is an object with boolean options "what kind of changes to react on":
+- `childList` -- changes in the direct children of `node`,
+- `subtree` -- in all descendants of `node`,
+- `attributes` -- attributes of `node`,
+- `attributeOldValue` -- record the old value of attribute (infers `attributes`),
+- `characterData` -- whether to observe `node.data` (text content),
+- `characterDataOldValue` -- record the old value of `node.data` (infers `characterData`),
+- `attributeFilter` -- an array of attribute names, to observe only selected ones.
+
+Then after any changes, the `callback` is executed, with a list of [MutationRecord](https://dom.spec.whatwg.org/#mutationrecord) objects as the first argument, and the observer itself as the second argument.
+
+[MutationRecord](https://dom.spec.whatwg.org/#mutationrecord) objects have properties:
+
+- `type` -- mutation type, one of
+    - `"attributes"` (attribute modified)
+    - `"characterData"` (data modified)
+    - `"childList"` (elements added/removed),
+- `target` -- where the change occured: an element for "attributes", or text node for "characterData", or an element for a "childList" mutation,
+- `addedNodes/removedNodes`  -- nodes that were added/removed,
+- `previousSibling/nextSibling` -- the previous and next sibling to added/removed nodes,
+- `attributeName/attributeNamespace` -- the name/namespace (for XML) of the changed attribute,
+- `oldValue` -- the previous value, only for attribute or text changes.
+
+
+For example, here's a `<div>` with `contentEditable` attribute. That attribute allows us to focus on it and edit.
+
+```html run
+<div contentEditable id="elem">Edit <b>me</b>, please</div>
+
+<script>
+let observer = new MutationObserver(mutationRecords => {
+  console.log(mutationRecords); // console.log(the changes)
+});
+observer.observe(elem, {
+  // observe everything except attributes
+  childList: true,
+  subtree: true,
+  characterDataOldValue: true
+});
+</script>
+```
+
+If we change the text inside `<b>me</b>`, we'll get a single mutation:
+
+```js
+mutationRecords = [{
+  type: "characterData",
+  oldValue: "me",
+  target: <text node>,
+  // other properties empty
+}];
+```
+
+If we select and remove the `<b>me</b>` altogether, we'll get multiple mutations:
+
+```js
+mutationRecords = [{
+  type: "childList",
+  target: <div#elem>,
+  removedNodes: [<b>],
+  nextSibling: <text node>,
+  previousSibling: <text node>
+  // other properties empty
+}, {
+  type: "characterData"
+  target: <text node>
+  // ...details depend on how the browser handles the change
+  // it may coalesce two adjacent text nodes "Edit " and ", please" into one node
+  // or it can just delete the extra space after "Edit".
+  // may be one mutation or a few
+}];
+```
+
+## Observer use case
+
+When `MutationObserver` is needed? Is there a scenario when such thing can be useful?
+
+Sure, we can track something like `contentEditable` and create "undo/redo" stack, but here's  an example where `MutationObserver` is good from architectural standpoint.
+
+Let's say we're making a website about programming, like this one. Naturally, articles and other materials may contain source code snippets.
+
+An HTML code snippet looks like this:
+```html
+...
+<pre class="language-javascript"><code>
+  // here's the code
+  let hello = "world";
+</code></pre>
+...
+```
+
+There's also a JavaScript highlighting library, e.g. [Prism.js](https://prismjs.com/). A call to `Prism.highlightElem(pre)` examines the contents of such `pre` elements and adds colored syntax highlighting, similar to what you in examples here, this page.
+
+Generally, when a page loads, e.g. at the bottom of the page, we can search for elements `pre[class*="language"]` and call `Prism.highlightElem` on them:
+
+```js
+// highlight all code snippets on the page
+document.querySelectorAll('pre[class*="language"]').forEach(Prism.highlightElem);
+```
+
+Now the `<pre>` snippet looks like this (without line numbers by default):
+
+```js
+// here's the code
+let hello = "world";
+```
+
+Everything's simple so far, right? There are `<pre>` code snippets in HTML, we highlight them.
+
+Now let's go on. Let's say we're going to dynamically fetch materials from a server. We'll study methods for that [later in the tutorial](info:fetch-basics). For now it only matters that we fetch an HTML article from a webserver and display it on demand:
+
+```js
+let article = /* fetch new content from server */
+articleElem.innerHTML = article;
+```
+
+The new `article` HTML may contain code snippets. We need to call `Prism.highlightElem` on them, otherwise they won't get highlighted.
+
+**Who's responsibility is to call `Prism.highlightElem` for a dynamically loaded article?**
+
+We could append that call to the code that loads an article, like this:
+
+```js
+let article = /* fetch new content from server */
+articleElem.innerHTML = article;
+
+*!*
+let snippets = articleElem.querySelectorAll('pre[class*="language-"]');
+snippets.forEach(Prism.highlightElem);
+*/!*
+```
+
+...But imagine, we have many places where we load contents with code: articles, quizzes, forum posts. Do we need to put the highlighting call everywhere? Then we need to be careful, not to forget about it.
+
+And what if we load the content into a third-party engine? E.g. we have a forum written by someone else, that loads contents dynamically, and we'd like to add syntax highlighting to it. No one likes to patch third-party scripts.
+
+Luckily, there's another option.
+
+We can use `MutationObserver` to automatically detect code snippets inserted in the page and highlight them.
+
+So we'll handle the highlighting functionality in one place, relieving us from the need to integrate it.
+
+## Dynamic highlight demo
+
+Here's the working example.
+
+If you run this code, it starts observing the element below and highlighting any code snippets that appear there:
+
+```js run
+let observer = new MutationObserver(mutations => {
+
+  for(let mutation of mutations) {
+    // examine new nodes
+
+    for(let node of mutation.addedNodes) {
+      // skip newly added text nodes
+      if (!(node instanceof HTMLElement)) continue;
+
+      // check the inserted element for being a code snippet
+      if (node.matches('pre[class*="language-"]')) {
+        Prism.highlightElement(node);
+      }
+
+      // search its subtree for code snippets
+      for(let elem of node.querySelectorAll('pre[class*="language-"]')) {
+        Prism.highlightElement(elem);
+      }
+    }
+  }
+
+});
+
+let demoElem = document.getElementById('highlight-demo');
+
+observer.observe(demoElem, {childList: true, subtree: true});
+```
+
+<p id="highlight-demo" style="border: 1px solid #ddd">Demo element with <code>id="highlight-demo"</code>, obverved by the example above.</p>
+
+The code below populates `innerHTML`. If you've run the code above, snippets will get highlighted:
+
+```js run
+let demoElem = document.getElementById('highlight-demo');
+
+// dynamically insert content with code snippets
+demoElem.innerHTML = `A code snippet is below:
+  <pre class="language-javascript"><code> let hello = "world!"; </code></pre>
+  <div>Another one:</div>
+  <div>
+    <pre class="language-css"><code>.class { margin: 5px; } </code></pre>
+  </div>
+`;
+```
+
+Now we have `MutationObserver` that can track all highlighting in observed elements or the whole `document`. We can add/remove code snippets in HTML without thinking about it.
+
+
+## Garbage collection
+
+Observers use weak references to nodes internally. That is: if a node is removed from DOM, and becomes unreachable, then it becomes garbage collected, an observer doesn't prevent that.
+
+Still, we can release observers any time:
+
+- `observer.disconnect()` -- stops the observation.
+
+Additionally:
+
+- `mutationRecords = observer.takeRecords()` -- gets a list of unprocessed mutation records, those that happened, but the callback did not handle them.
+
+```js
+// we're going to disconnect the observer
+// it might have not yet handled some mutations
+let mutationRecords = observer.takeRecords();
+// process mutationRecords
+
+// now all handled, disconnect
+observer.disconnect();
+```
+
+## Summary  
+
+`MutationObserver` can react on changes in DOM: attributes, added/removed elements, text content.
+
+We can use it to track changes introduced by other parts of our own or 3rd-party code.
+
+For example, to post-process dynamically inserted content, as demo `innerHTML`, like highlighting in the example above.
diff --git a/10-misc/index.md b/10-misc/index.md
new file mode 100644
index 000000000..65ab3188a
--- /dev/null
+++ b/10-misc/index.md
@@ -0,0 +1,4 @@
+
+# Miscellaneous
+
+Not yet categorized articles.
diff --git a/2-ui/1-document/01-browser-environment/article.md b/2-ui/1-document/01-browser-environment/article.md
index 09f553436..fbc85304b 100644
--- a/2-ui/1-document/01-browser-environment/article.md
+++ b/2-ui/1-document/01-browser-environment/article.md
@@ -4,7 +4,11 @@ Il linguaggio JavaScript è stato inizialmente creato per i browser. Da allora,
 
 La piattaforma di utilizzo può essere un browser, un web-server, una lavatrice o un qualunque altro tipo di *host*. Ognuno di essi fornisce delle funzionalità specifiche alla piattaforma stessa. Secondo la specifica JavaScript questa è la definizione di *ambiente host*
 
+<<<<<<< HEAD
 Un ambiente host, oltre alle funzionalità core del linguaggio, fornisce oggetti e funzioni specifiche della piattaforma. I browser web, ad esempio, permettono di interagire con le pagine web, mentre Node.JS fornisce funzionalità dedicate al server e così via.
+=======
+A host environment provides platform-specific objects and functions additional to the language core. Web browsers give a means to control web pages. Node.js provides server-side features, and so on.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Di seguito una panoramica di cosa succede quando JavaScript viene eseguito nel browser:
 
diff --git a/2-ui/1-document/01-browser-environment/windowObjects.png b/2-ui/1-document/01-browser-environment/windowObjects.png
index 81803bd09..5408ecb15 100644
Binary files a/2-ui/1-document/01-browser-environment/windowObjects.png and b/2-ui/1-document/01-browser-environment/windowObjects.png differ
diff --git a/2-ui/1-document/01-browser-environment/windowObjects@2x.png b/2-ui/1-document/01-browser-environment/windowObjects@2x.png
index e6dae7c3d..d84b380d5 100644
Binary files a/2-ui/1-document/01-browser-environment/windowObjects@2x.png and b/2-ui/1-document/01-browser-environment/windowObjects@2x.png differ
diff --git a/2-ui/1-document/02-dom-nodes/article.md b/2-ui/1-document/02-dom-nodes/article.md
index f3a9faaed..e1616c264 100644
--- a/2-ui/1-document/02-dom-nodes/article.md
+++ b/2-ui/1-document/02-dom-nodes/article.md
@@ -181,7 +181,11 @@ drawHtmlTree(node6, 'div.domtree', 690, 500);
 
 Vediamo ora un nuovo tipo di nodo -- *nodo commento*, etichettato come `#comment`.
 
+<<<<<<< HEAD
 Potremmo chiederci "perché il commento viene aggiunto al DOM? Non incide sul risultato grafico finale". Esiste in realtà una regola che se qualcosa è nell'HTML, allora deve essere presente anche nell'alberatura del DOM.
+=======
+We may think -- why is a comment added to the DOM? It doesn't affect the visual representation in any way. But there's a rule -- if something's in HTML, then it also must be in the DOM tree.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 **Tutto ciò che è presente nell'HTML, anche i commenti, finisce per essere parte del DOM.**
 
diff --git a/2-ui/1-document/03-dom-navigation/article.md b/2-ui/1-document/03-dom-navigation/article.md
index 976e595a2..1e1e4058c 100644
--- a/2-ui/1-document/03-dom-navigation/article.md
+++ b/2-ui/1-document/03-dom-navigation/article.md
@@ -7,11 +7,11 @@ libs:
 
 # Walking the DOM
 
-The DOM allows to do anything with elements and their contents, but first we need to reach the corresponding DOM object, get it into a variable, and then we are able to modify it.
+The DOM allows us to do anything with elements and their contents, but first we need to reach the corresponding DOM object, get it into a variable, and then we are able to modify it.
 
 All operations on the DOM start with the `document` object. From it we can access any node.
 
-Here's a picture of links that allow to travel between DOM nodes:
+Here's a picture of links that allow for travel between DOM nodes:
 
 ![](dom-links.png)
 
@@ -155,9 +155,9 @@ The first thing is nice. The second is tolerable, because we can use `Array.from
 ```warn header="DOM collections are read-only"
 DOM collections, and even more -- *all* navigation properties listed in this chapter are read-only.
 
-We can't replace a child by something else assigning `childNodes[i] = ...`.
+We can't replace a child by something else by assigning `childNodes[i] = ...`.
 
-Changing DOM needs other methods, we'll see them in the next chapter.
+Changing DOM needs other methods. We will see them in the next chapter.
 ```
 
 ```warn header="DOM collections are live"
@@ -237,7 +237,12 @@ alert( document.documentElement.parentElement ); // null
 
 In other words, the `documentElement` (`<html>`) is the root node. Formally, it has `document` as its parent. But `document` is not an element node, so `parentNode` returns it and `parentElement` does not.
 
-Sometimes that matters when we're walking over the chain of parents and call a method on each of them, but `document` doesn't have it, so we exclude it.
+This loop travels up from an arbitrary element `elem` to `<html>`, but not to the `document`:
+```js
+while(elem = elem.parentElement) {
+  alert( elem ); // parent chain till <html>
+}
+```
 ````
 
 Let's modify one of the examples above: replace `childNodes` with `children`. Now it shows only elements:
@@ -309,7 +314,7 @@ An example of usage:
 
 The specification: [tabular data](https://html.spec.whatwg.org/multipage/tables.html).
 
-There are also additional navigation properties for HTML forms. We'll look at them later when start working with forms.
+There are also additional navigation properties for HTML forms. We'll look at them later when we start working with forms.
 
 # Summary
 
diff --git a/2-ui/1-document/03-dom-navigation/dom-links-elements.png b/2-ui/1-document/03-dom-navigation/dom-links-elements.png
index f7eef5d1f..c0e2f6941 100644
Binary files a/2-ui/1-document/03-dom-navigation/dom-links-elements.png and b/2-ui/1-document/03-dom-navigation/dom-links-elements.png differ
diff --git a/2-ui/1-document/03-dom-navigation/dom-links-elements@2x.png b/2-ui/1-document/03-dom-navigation/dom-links-elements@2x.png
index cf4e220cf..663471177 100644
Binary files a/2-ui/1-document/03-dom-navigation/dom-links-elements@2x.png and b/2-ui/1-document/03-dom-navigation/dom-links-elements@2x.png differ
diff --git a/2-ui/1-document/03-dom-navigation/dom-links.png b/2-ui/1-document/03-dom-navigation/dom-links.png
index 25b25b377..d6b5ddf96 100644
Binary files a/2-ui/1-document/03-dom-navigation/dom-links.png and b/2-ui/1-document/03-dom-navigation/dom-links.png differ
diff --git a/2-ui/1-document/03-dom-navigation/dom-links@2x.png b/2-ui/1-document/03-dom-navigation/dom-links@2x.png
index 84cd33d4e..827552f65 100644
Binary files a/2-ui/1-document/03-dom-navigation/dom-links@2x.png and b/2-ui/1-document/03-dom-navigation/dom-links@2x.png differ
diff --git a/2-ui/1-document/04-searching-elements-dom/article.md b/2-ui/1-document/04-searching-elements-dom/article.md
index 3a7a9aeee..18ce24eba 100644
--- a/2-ui/1-document/04-searching-elements-dom/article.md
+++ b/2-ui/1-document/04-searching-elements-dom/article.md
@@ -1,13 +1,14 @@
-# Searching: getElement* and querySelector*
+# Searching: getElement*, querySelector*
 
 DOM navigation properties are great when elements are close to each other. What if they are not? How to get an arbitrary element of the page?
 
 There are additional searching methods for that.
+
 ## document.getElementById or just id
 
 If an element has the `id` attribute, then there's a global variable by the name from that `id`.
 
-We can use it to access the element, like this:
+We can use it to immediately access the element no matter where it is:
 
 ```html run
 <div id="*!*elem*/!*">
@@ -24,7 +25,9 @@ We can use it to access the element, like this:
 </script>
 ```
 
-That's unless we declare the same-named variable by our own:
+The behavior is described [in the specification](http://www.whatwg.org/specs/web-apps/current-work/#dom-window-nameditem), but it is supported mainly for compatibility. The browser tries to help us by mixing namespaces of JS and DOM. Good for very simple scripts, but there may be name conflicts. Also, when we look in JS and don't have HTML in view, it's not obvious where the variable comes from.
+
+If we declare a variable with the same name, it takes precedence:
 
 ```html run untrusted height=0
 <div id="elem"></div>
@@ -36,8 +39,6 @@ That's unless we declare the same-named variable by our own:
 </script>
 ```
 
-The behavior is described [in the specification](http://www.whatwg.org/specs/web-apps/current-work/#dom-window-nameditem), but it is supported mainly for compatibility. The browser tries to help us by mixing namespaces of JS and DOM. Good for very simple scripts, but there may be name conflicts. Also, when we look in JS and don't have HTML in view, it's not obvious where the variable comes from.
-
 The better alternative is to use a special method `document.getElementById(id)`.
 
 For instance:
@@ -68,104 +69,9 @@ If there are multiple elements with the same `id`, then the behavior of correspo
 The method `getElementById` that can be called only on `document` object. It looks for the given `id` in the whole document.
 ```
 
-## getElementsBy*
-
-There are also other methods to look for nodes:
-
-- `elem.getElementsByTagName(tag)` looks for elements with the given tag and returns the collection of them. The `tag` parameter can also be a star `"*"` for "any tags".
-
-For instance:
-```js
-// get all divs in the document
-let divs = document.getElementsByTagName('div');
-```
-
-This method is callable in the context of any DOM element.
-
-Let's find all `input` tags inside the table:
-
-```html run height=50
-<table id="table">
-  <tr>
-    <td>Your age:</td>
-
-    <td>
-      <label>
-        <input type="radio" name="age" value="young" checked> less than 18
-      </label>
-      <label>
-        <input type="radio" name="age" value="mature"> from 18 to 50
-      </label>
-      <label>
-        <input type="radio" name="age" value="senior"> more than 60
-      </label>
-    </td>
-  </tr>
-</table>
-
-<script>
-*!*
-  let inputs = table.getElementsByTagName('input');
-*/!*
-
-  for (let input of inputs) {
-    alert( input.value + ': ' + input.checked );
-  }
-</script>
-```
-
-```warn header="Don't forget the `\"s\"` letter!"
-Novice developers sometimes forget the letter `"s"`. That is, they try to call `getElementByTagName` instead of <code>getElement<b>s</b>ByTagName</code>.
-
-The `"s"` letter is absent in `getElementById`, because it returns a single element. But `getElementsByTagName` returns a collection of elements, so there's `"s"` inside.
-```
-
-````warn header="It returns a collection, not an element!"
-Another widespread novice mistake is to write:
-
-```js
-// doesn't work
-document.getElementsByTagName('input').value = 5;
-```
-
-That won't work, because it takes a *collection* of inputs and assigns the value to it rather than to elements inside it.
-
-We should either iterate over the collection or get an element by its index, and then assign, like this:
-
-```js
-// should work (if there's an input)
-document.getElementsByTagName('input')[0].value = 5;
-```
-````
-
-There are also other rarely used methods of this kind:
-
-- `elem.getElementsByClassName(className)` returns elements that have the given CSS class. Elements may have other classes too.
-- `document.getElementsByName(name)` returns elements with the given `name` attribute, document-wide. Exists for historical reasons, very rarely used, we mention it here only for completeness.
-
-For instance:
-
-```html run height=50
-<form name="my-form">
-  <div class="article">Article</div>
-  <div class="long article">Long article</div>
-</form>
-
-<script>
-  // find by name attribute
-  let form = document.getElementsByName('my-form')[0];
-
-  // find by class inside the form
-  let articles = form.getElementsByClassName('article');
-  alert(articles.length); // 2, found two elements with class "article"
-</script>
-```
-
 ## querySelectorAll [#querySelectorAll]
 
-Now goes the heavy artillery.
-
-The call to `elem.querySelectorAll(css)` returns all elements inside `elem` matching the given CSS selector. That's the most often used and powerful method.
+By far, the most versatile method, `elem.querySelectorAll(css)` returns all elements inside `elem` matching the given CSS selector.
 
 Here we look for all `<li>` elements that are last children:
 
@@ -195,7 +101,6 @@ This method is indeed powerful, because any CSS selector can be used.
 Pseudo-classes in the CSS selector like `:hover` and `:active` are also supported. For instance, `document.querySelectorAll(':hover')` will return the collection with elements that the pointer is  over now (in nesting order: from the outermost `<html>` to the most nested one).
 ```
 
-
 ## querySelector [#querySelector]
 
 The call to `elem.querySelector(css)` returns the first element for the given CSS selector.
@@ -230,9 +135,7 @@ For instance:
 
 ## closest
 
-All elements that are directly above the given one are called its *ancestors*.
-
-In other words, ancestors are: parent, the parent of parent, its parent and so on. The ancestors together form the chain of parents from the element to the top.
+*Ancestors* of an element are: parent, the parent of parent, its parent and so on. The ancestors together form the chain of parents from the element to the top.
 
 The method `elem.closest(css)` looks the nearest ancestor that matches the CSS-selector. The `elem` itself is also included in the search.
 
@@ -260,14 +163,106 @@ For instance:
 </script>
 ```
 
+## getElementsBy*
+
+There are also other methods to look for nodes by a tag, class, etc.
+
+Today, they are mostly history, as `querySelector` is more powerful and shorter to write.
+
+So here we cover them mainly for completeness, while you can still find them in the old scripts.
+
+- `elem.getElementsByTagName(tag)` looks for elements with the given tag and returns the collection of them. The `tag` parameter can also be a star `"*"` for "any tags".
+- `elem.getElementsByClassName(className)` returns elements that have the given CSS class. Elements may have other classes too.
+- `document.getElementsByName(name)` returns elements with the given `name` attribute, document-wide. very rarely used.
+
+For instance:
+```js
+// get all divs in the document
+let divs = document.getElementsByTagName('div');
+```
+
+Let's find all `input` tags inside the table:
+
+```html run height=50
+<table id="table">
+  <tr>
+    <td>Your age:</td>
+
+    <td>
+      <label>
+        <input type="radio" name="age" value="young" checked> less than 18
+      </label>
+      <label>
+        <input type="radio" name="age" value="mature"> from 18 to 50
+      </label>
+      <label>
+        <input type="radio" name="age" value="senior"> more than 60
+      </label>
+    </td>
+  </tr>
+</table>
+
+<script>
+*!*
+  let inputs = table.getElementsByTagName('input');
+*/!*
+
+  for (let input of inputs) {
+    alert( input.value + ': ' + input.checked );
+  }
+</script>
+```
+
+```warn header="Don't forget the `\"s\"` letter!"
+Novice developers sometimes forget the letter `"s"`. That is, they try to call `getElementByTagName` instead of <code>getElement<b>s</b>ByTagName</code>.
+
+The `"s"` letter is absent in `getElementById`, because it returns a single element. But `getElementsByTagName` returns a collection of elements, so there's `"s"` inside.
+```
+
+````warn header="It returns a collection, not an element!"
+Another widespread novice mistake is to write:
+
+```js
+// doesn't work
+document.getElementsByTagName('input').value = 5;
+```
+
+That won't work, because it takes a *collection* of inputs and assigns the value to it rather than to elements inside it.
+
+We should either iterate over the collection or get an element by its index, and then assign, like this:
+
+```js
+// should work (if there's an input)
+document.getElementsByTagName('input')[0].value = 5;
+```
+````
+
+Looking for `.article` elements:
+
+```html run height=50
+<form name="my-form">
+  <div class="article">Article</div>
+  <div class="long article">Long article</div>
+</form>
+
+<script>
+  // find by name attribute
+  let form = document.getElementsByName('my-form')[0];
+
+  // find by class inside the form
+  let articles = form.getElementsByClassName('article');
+  alert(articles.length); // 2, found two elements with class "article"
+</script>
+```
+
 ## Live collections
 
 All methods `"getElementsBy*"` return a *live* collection. Such collections always reflect the current state of the document and "auto-update" when it changes.
 
 In the example below, there are two scripts.
 
-1. The first one creates a reference to the collection of `<div>`. As of now, it's length is `1`.
-2. The second scripts runs after the browser meets one more `<div>`, so it's length is `2`.
+1. The first one creates a reference to the collection of `<div>`. As of now, its length is `1`.
+2. The second scripts runs after the browser meets one more `<div>`, so its length is `2`.
 
 ```html run
 <div>First div</div>
@@ -327,6 +322,18 @@ There are 6 main methods to search for nodes in DOM:
 </thead>
 <tbody>
 <tr>
+<td><code>querySelector</code></td>
+<td>CSS-selector</td>
+<td>✔</td>
+<td>-</td>
+</tr>
+<tr>
+<td><code>querySelectorAll</code></td>
+<td>CSS-selector</td>
+<td>✔</td>
+<td>-</td>
+</tr>
+<tr>
 <td><code>getElementById</code></td>
 <td><code>id</code></td>
 <td>-</td>
@@ -350,24 +357,10 @@ There are 6 main methods to search for nodes in DOM:
 <td>✔</td>
 <td>✔</td>
 </tr>
-<tr>
-<td><code>querySelector</code></td>
-<td>CSS-selector</td>
-<td>✔</td>
-<td>-</td>
-</tr>
-<tr>
-<td><code>querySelectorAll</code></td>
-<td>CSS-selector</td>
-<td>✔</td>
-<td>-</td>
-</tr>
 </tbody>
 </table>
 
-Please note that methods `getElementById` and `getElementsByName` can only be called in the context of the document: `document.getElementById(...)`. But not on an element: `elem.getElementById(...)` would cause an error.
-
-Other methods can be called on elements too. For instance `elem.querySelectorAll(...)` will search inside `elem` (in the DOM subtree).
+By far the most used are `querySelector` and `querySelectorAll`, but `getElementBy*` can be sporadically helpful or found in the old scripts.
 
 Besides that:
 
diff --git a/2-ui/1-document/05-basic-dom-node-properties/dom-class-hierarchy.png b/2-ui/1-document/05-basic-dom-node-properties/dom-class-hierarchy.png
index e48064cce..d82e90376 100644
Binary files a/2-ui/1-document/05-basic-dom-node-properties/dom-class-hierarchy.png and b/2-ui/1-document/05-basic-dom-node-properties/dom-class-hierarchy.png differ
diff --git a/2-ui/1-document/05-basic-dom-node-properties/dom-class-hierarchy@2x.png b/2-ui/1-document/05-basic-dom-node-properties/dom-class-hierarchy@2x.png
index 343f4890d..8a5ce5c0b 100644
Binary files a/2-ui/1-document/05-basic-dom-node-properties/dom-class-hierarchy@2x.png and b/2-ui/1-document/05-basic-dom-node-properties/dom-class-hierarchy@2x.png differ
diff --git a/2-ui/1-document/06-dom-attributes-and-properties/2-yellow-links/task.md b/2-ui/1-document/06-dom-attributes-and-properties/2-yellow-links/task.md
index f7db9a042..b0a8ab7b1 100644
--- a/2-ui/1-document/06-dom-attributes-and-properties/2-yellow-links/task.md
+++ b/2-ui/1-document/06-dom-attributes-and-properties/2-yellow-links/task.md
@@ -7,7 +7,7 @@ importance: 3
 Make all external links orange by altering their `style` property.
 
 A link is external if:
-- It's `href` has `://` in it
+- Its `href` has `://` in it
 - But doesn't start with `http://internal.com`.
 
 Example:
diff --git a/2-ui/1-document/07-modifying-document/10-clock-setinterval/task.md b/2-ui/1-document/07-modifying-document/10-clock-setinterval/task.md
index 70bc2ae9d..a1b53e337 100644
--- a/2-ui/1-document/07-modifying-document/10-clock-setinterval/task.md
+++ b/2-ui/1-document/07-modifying-document/10-clock-setinterval/task.md
@@ -8,4 +8,4 @@ Create a colored clock like here:
 
 [iframe src="solution" height=60]
 
-Use HTML/CSS for the styling, Javascript only updates time in elements.
+Use HTML/CSS for the styling, JavaScript only updates time in elements.
diff --git a/2-ui/1-document/07-modifying-document/7-create-object-tree/innerhtml.view/index.html b/2-ui/1-document/07-modifying-document/7-create-object-tree/innerhtml.view/index.html
index 9ba40a6d0..fd85e6c76 100644
--- a/2-ui/1-document/07-modifying-document/7-create-object-tree/innerhtml.view/index.html
+++ b/2-ui/1-document/07-modifying-document/7-create-object-tree/innerhtml.view/index.html
@@ -29,11 +29,12 @@
 
     function createTreeText(obj) { // standalone recursive function
       let li = '';
+      let ul;
       for (let key in obj) {
         li += '<li>' + key + createTreeText(obj[key]) + '</li>';
       }
       if (li) {
-        let ul = '<ul>' + li + '</ul>'
+        ul = '<ul>' + li + '</ul>'
       }
       return ul || '';
     }
diff --git a/2-ui/1-document/07-modifying-document/article.md b/2-ui/1-document/07-modifying-document/article.md
index 9c38b3344..16aacb456 100644
--- a/2-ui/1-document/07-modifying-document/article.md
+++ b/2-ui/1-document/07-modifying-document/article.md
@@ -136,7 +136,7 @@ Here's a brief list of methods to insert a node into a parent element (`parentEl
     </script>
     ```
     To insert `newLi` as the first element, we can do it like this:
-    
+
     ```js
     list.insertBefore(newLi, list.firstChild);
     ```
@@ -335,13 +335,81 @@ An example of copying the message:
 </script>
 ```
 
+
+## DocumentFragment [#document-fragment]
+
+`DocumentFragment` is a special DOM node that serves as a wrapper to pass around groups of nodes.
+
+We can append other nodes to it, but when we insert it somewhere, then it "disappears", leaving its content inserted instead.
+
+For example, `getListContent` below generates a fragment with `<li>` items, that are later inserted into `<ul>`:
+
+```html run
+<ul id="ul"></ul>
+
+<script>
+function getListContent() {
+  let fragment = new DocumentFragment();
+
+  for(let i=1; i<=3; i++) {
+    let li = document.createElement('li');
+    li.append(i);
+    fragment.append(li);
+  }
+
+  return fragment;
+}
+
+*!*
+ul.append(getListContent()); // (*)
+*/!*
+</script>
+```
+
+Please note, at the last line `(*)` we append `DocumentFragment`, but it "blends in", so the resulting structure will be:
+
+```html
+<ul>
+  <li>1</li>
+  <li>2</li>
+  <li>3</li>
+</ul>
+```
+
+`DocumentFragment` is rarely used explicitly. Why append to a special kind of node, if we can return an array of nodes instead? Rewritten example:
+
+```html run
+<ul id="ul"></ul>
+
+<script>
+function getListContent() {
+  let result = [];
+
+  for(let i=1; i<=3; i++) {
+    let li = document.createElement('li');
+    li.append(i);
+    result.push(li);
+  }
+
+  return result;
+}
+
+*!*
+ul.append(...getListContent()); // append + "..." operator = friends!
+*/!*
+</script>
+```
+
+We mention `DocumentFragment` mainly because there are some concepts on top of it, like [template](info:template-element) element, that we'll cover much later.
+
+
 ## Removal methods
 
 To remove nodes, there are the following methods:
 
 
 `parentElem.removeChild(node)`
-: Removes `elem` from  `parentElem` (assuming it's a child).
+: Removes `node` from  `parentElem` (assuming it's a child).
 
 `node.remove()`
 : Removes the `node` from its place.
diff --git a/2-ui/1-document/07-modifying-document/before-prepend-append-after.png b/2-ui/1-document/07-modifying-document/before-prepend-append-after.png
index 5bff84d85..858056f72 100644
Binary files a/2-ui/1-document/07-modifying-document/before-prepend-append-after.png and b/2-ui/1-document/07-modifying-document/before-prepend-append-after.png differ
diff --git a/2-ui/1-document/07-modifying-document/before-prepend-append-after@2x.png b/2-ui/1-document/07-modifying-document/before-prepend-append-after@2x.png
index 44c369ee6..9d6894314 100644
Binary files a/2-ui/1-document/07-modifying-document/before-prepend-append-after@2x.png and b/2-ui/1-document/07-modifying-document/before-prepend-append-after@2x.png differ
diff --git a/2-ui/1-document/07-modifying-document/insert-adjacent.png b/2-ui/1-document/07-modifying-document/insert-adjacent.png
index 08063bc51..7cf2f5973 100644
Binary files a/2-ui/1-document/07-modifying-document/insert-adjacent.png and b/2-ui/1-document/07-modifying-document/insert-adjacent.png differ
diff --git a/2-ui/1-document/07-modifying-document/insert-adjacent@2x.png b/2-ui/1-document/07-modifying-document/insert-adjacent@2x.png
index 60333ad1b..fcb14017a 100644
Binary files a/2-ui/1-document/07-modifying-document/insert-adjacent@2x.png and b/2-ui/1-document/07-modifying-document/insert-adjacent@2x.png differ
diff --git a/2-ui/1-document/08-styles-and-classes/article.md b/2-ui/1-document/08-styles-and-classes/article.md
index ed9db3032..5159c532d 100644
--- a/2-ui/1-document/08-styles-and-classes/article.md
+++ b/2-ui/1-document/08-styles-and-classes/article.md
@@ -116,7 +116,7 @@ Sometimes we want to assign a style property, and later remove it.
 
 For instance, to hide an element, we can set `elem.style.display = "none"`.
 
-Then later we may want to remove the `style.display` as if it were not set. Instead of `delete elem.style.display` we should assign an empty line to it: `elem.style.display = ""`.
+Then later we may want to remove the `style.display` as if it were not set. Instead of `delete elem.style.display` we should assign an empty string to it: `elem.style.display = ""`.
 
 ```js run
 // if we run this code, the <body> "blinks"
@@ -207,7 +207,7 @@ For instance, here `style` doesn't see the margin:
 </body>
 ```
 
-...But what if we need, say, to increase the margin by 20px? We want the current value for the start.
+...But what if we need, say, to increase the margin by 20px? We would want the current value of it.
 
 There's another method for that: `getComputedStyle`.
 
@@ -281,7 +281,7 @@ Visited links may be colored using `:visited` CSS pseudoclass.
 
 But `getComputedStyle` does not give access to that color, because otherwise an arbitrary page could find out whether the user visited a link by creating it on the page and checking the styles.
 
-JavaScript we may not see the styles applied by `:visited`. And also, there's a limitation in CSS that forbids to apply geometry-changing styles in `:visited`. That's to guarantee that there's no sideway for an evil page to test if a link was visited and hence to break the privacy.
+JavaScript may not see the styles applied by `:visited`. And also, there's a limitation in CSS that forbids to apply geometry-changing styles in `:visited`. That's to guarantee that there's no sideway for an evil page to test if a link was visited and hence to break the privacy.
 ```
 
 ## Summary
diff --git a/2-ui/1-document/09-size-and-scroll/4-put-ball-in-center/field.png b/2-ui/1-document/09-size-and-scroll/4-put-ball-in-center/field.png
index 098f9eb6d..67b9019a0 100644
Binary files a/2-ui/1-document/09-size-and-scroll/4-put-ball-in-center/field.png and b/2-ui/1-document/09-size-and-scroll/4-put-ball-in-center/field.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/4-put-ball-in-center/field@2x.png b/2-ui/1-document/09-size-and-scroll/4-put-ball-in-center/field@2x.png
index 3ecb29375..fe58f3542 100644
Binary files a/2-ui/1-document/09-size-and-scroll/4-put-ball-in-center/field@2x.png and b/2-ui/1-document/09-size-and-scroll/4-put-ball-in-center/field@2x.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/article.md b/2-ui/1-document/09-size-and-scroll/article.md
index 952dd7275..774857f3f 100644
--- a/2-ui/1-document/09-size-and-scroll/article.md
+++ b/2-ui/1-document/09-size-and-scroll/article.md
@@ -64,7 +64,7 @@ The `offsetParent` is the nearest ancestor that is:
 2. or `<td>`, `<th>`, `<table>`,
 2. or `<body>`.
 
-In most practical cases we can use `offsetParent` to get the nearest CSS-positioned ancestor. And `offsetLeft/offsetTop` provide x/y coordinates relative to it's upper-left corner.
+In most practical cases we can use `offsetParent` to get the nearest CSS-positioned ancestor. And `offsetLeft/offsetTop` provide x/y coordinates relative to its upper-left corner.
 
 In the example below the inner `<div>` has `<main>` as `offsetParent` and `offsetLeft/offsetTop` shifts from its upper-left corner (`180`):
 
diff --git a/2-ui/1-document/09-size-and-scroll/metric-all.png b/2-ui/1-document/09-size-and-scroll/metric-all.png
index a6335bcd8..6060b9890 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-all.png and b/2-ui/1-document/09-size-and-scroll/metric-all.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-all@2x.png b/2-ui/1-document/09-size-and-scroll/metric-all@2x.png
index e084c257b..3c53be1dd 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-all@2x.png and b/2-ui/1-document/09-size-and-scroll/metric-all@2x.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-client-left-top-rtl.png b/2-ui/1-document/09-size-and-scroll/metric-client-left-top-rtl.png
index ffb10aa1b..efcc9440b 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-client-left-top-rtl.png and b/2-ui/1-document/09-size-and-scroll/metric-client-left-top-rtl.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-client-left-top-rtl@2x.png b/2-ui/1-document/09-size-and-scroll/metric-client-left-top-rtl@2x.png
index 48510e6e0..9b7edcf57 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-client-left-top-rtl@2x.png and b/2-ui/1-document/09-size-and-scroll/metric-client-left-top-rtl@2x.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-client-left-top.png b/2-ui/1-document/09-size-and-scroll/metric-client-left-top.png
index 33faf9be7..787557205 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-client-left-top.png and b/2-ui/1-document/09-size-and-scroll/metric-client-left-top.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-client-left-top@2x.png b/2-ui/1-document/09-size-and-scroll/metric-client-left-top@2x.png
index a8e170eab..8034c7aff 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-client-left-top@2x.png and b/2-ui/1-document/09-size-and-scroll/metric-client-left-top@2x.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-client-width-height.png b/2-ui/1-document/09-size-and-scroll/metric-client-width-height.png
index d10edb5f6..d50d1186f 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-client-width-height.png and b/2-ui/1-document/09-size-and-scroll/metric-client-width-height.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-client-width-height@2x.png b/2-ui/1-document/09-size-and-scroll/metric-client-width-height@2x.png
index f31f483e4..76017b9ee 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-client-width-height@2x.png and b/2-ui/1-document/09-size-and-scroll/metric-client-width-height@2x.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-client-width-nopadding.png b/2-ui/1-document/09-size-and-scroll/metric-client-width-nopadding.png
index 8280e40f1..173bf1529 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-client-width-nopadding.png and b/2-ui/1-document/09-size-and-scroll/metric-client-width-nopadding.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-client-width-nopadding@2x.png b/2-ui/1-document/09-size-and-scroll/metric-client-width-nopadding@2x.png
index 5a73f87a9..2d145d77f 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-client-width-nopadding@2x.png and b/2-ui/1-document/09-size-and-scroll/metric-client-width-nopadding@2x.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-css.png b/2-ui/1-document/09-size-and-scroll/metric-css.png
index a28bbab78..5579b4abd 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-css.png and b/2-ui/1-document/09-size-and-scroll/metric-css.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-css@2x.png b/2-ui/1-document/09-size-and-scroll/metric-css@2x.png
index e4fd7bb87..c4df7706b 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-css@2x.png and b/2-ui/1-document/09-size-and-scroll/metric-css@2x.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-offset-parent.png b/2-ui/1-document/09-size-and-scroll/metric-offset-parent.png
index a0fba50d2..059ef13ef 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-offset-parent.png and b/2-ui/1-document/09-size-and-scroll/metric-offset-parent.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-offset-parent@2x.png b/2-ui/1-document/09-size-and-scroll/metric-offset-parent@2x.png
index 125a91e15..0f86b4f85 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-offset-parent@2x.png and b/2-ui/1-document/09-size-and-scroll/metric-offset-parent@2x.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-offset-width-height.png b/2-ui/1-document/09-size-and-scroll/metric-offset-width-height.png
index f25957848..82551b8e1 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-offset-width-height.png and b/2-ui/1-document/09-size-and-scroll/metric-offset-width-height.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-offset-width-height@2x.png b/2-ui/1-document/09-size-and-scroll/metric-offset-width-height@2x.png
index 7bfb24c22..805687cd6 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-offset-width-height@2x.png and b/2-ui/1-document/09-size-and-scroll/metric-offset-width-height@2x.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-scroll-top.png b/2-ui/1-document/09-size-and-scroll/metric-scroll-top.png
index 13c57161f..83f410837 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-scroll-top.png and b/2-ui/1-document/09-size-and-scroll/metric-scroll-top.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-scroll-top@2x.png b/2-ui/1-document/09-size-and-scroll/metric-scroll-top@2x.png
index bf0cf711a..1ef15502e 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-scroll-top@2x.png and b/2-ui/1-document/09-size-and-scroll/metric-scroll-top@2x.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-scroll-width-height.png b/2-ui/1-document/09-size-and-scroll/metric-scroll-width-height.png
index 197a5d764..54e6b9634 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-scroll-width-height.png and b/2-ui/1-document/09-size-and-scroll/metric-scroll-width-height.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-scroll-width-height@2x.png b/2-ui/1-document/09-size-and-scroll/metric-scroll-width-height@2x.png
index 1e2a20f54..d57c5c198 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-scroll-width-height@2x.png and b/2-ui/1-document/09-size-and-scroll/metric-scroll-width-height@2x.png differ
diff --git a/2-ui/1-document/10-size-and-scroll-window/article.md b/2-ui/1-document/10-size-and-scroll-window/article.md
index 4a62f56c6..b8c16a3c7 100644
--- a/2-ui/1-document/10-size-and-scroll-window/article.md
+++ b/2-ui/1-document/10-size-and-scroll-window/article.md
@@ -1,6 +1,6 @@
 # Window sizes and scrolling
 
-How to find out the width of the browser window? How to get the full height of the document, including the scrolled out part? How to scroll the page using JavaScript?
+How to find out the width and height of the browser window? How to get the full width and height of the document, including the scrolled out part? How to scroll the page using JavaScript?
 
 From the DOM point of view, the root document element is `document.documentElement`. That element corresponds to `<html>` and has geometry properties described in the [previous chapter](info:size-and-scroll). For some cases we can use it, but there are additional methods and peculiarities important enough to consider.
 
@@ -44,7 +44,7 @@ Theoretically, as the root document element is `documentElement.clientWidth/Heig
 
 These properties work well for regular elements. But for the whole page these properties do not work as intended. In Chrome/Safari/Opera if there's no scroll, then `documentElement.scrollHeight` may be even less than  `documentElement.clientHeight`! For regular elements that's a nonsense.
 
-To have a reliable full window size, we should take the maximum of these properties:
+To have a reliable result on the full document height, we should take the maximum of these properties:
 
 ```js run
 let scrollHeight = Math.max(
@@ -96,7 +96,7 @@ It should work, but smells like cross-browser incompatibilities. Not good. Fortu
 
     <button onclick="window.scrollBy(0,10)">window.scrollBy(0,10)</button>
     ```
-- The method `scrollTo(pageX,pageY)` scrolls the page relative to the document top-left corner. It's like setting `scrollLeft/scrollTop`.
+- The method `scrollTo(pageX,pageY)` scrolls the page relative to the document's top-left corner. It's like setting `scrollLeft/scrollTop`.
 
     To scroll to the very beginning, we can use `scrollTo(0,0)`.
 
@@ -129,7 +129,7 @@ And this button scrolls the page to show it at the bottom:
 
 Sometimes we need to make the document "unscrollable". For instance, when we need to cover it with a large message requiring immediate attention, and we want the visitor to interact with that message, not with the document.
 
-To make the document unscrollable, its enough to set `document.body.style.overflow = "hidden"`. The page will freeze on its current scroll.
+To make the document unscrollable, it's enough to set `document.body.style.overflow = "hidden"`. The page will freeze on its current scroll.
 
 ```online
 Try it:
@@ -145,7 +145,7 @@ We can use the same technique to "freeze" the scroll for other elements, not jus
 
 The drawback of the method is that the scrollbar disappears. If it occupied some space, then that space is now free, and the content "jumps" to fill it.
 
-That looks a bit odd, but can be worked around if we compare `clientWidth` before and after the freeze, and if it increased (the scrollbar disappeared) then add `padding` to `document.body` in place of the scrollbar, to keep the content width same.
+That looks a bit odd, but can be worked around if we compare `clientWidth` before and after the freeze, and if it increased (the scrollbar disappeared) then add `padding` to `document.body` in place of the scrollbar, to keep the content width the same.
 
 ## Summary
 
diff --git a/2-ui/1-document/10-size-and-scroll-window/document-client-width-height.png b/2-ui/1-document/10-size-and-scroll-window/document-client-width-height.png
index 76a45a7a7..a3cf95f11 100644
Binary files a/2-ui/1-document/10-size-and-scroll-window/document-client-width-height.png and b/2-ui/1-document/10-size-and-scroll-window/document-client-width-height.png differ
diff --git a/2-ui/1-document/10-size-and-scroll-window/document-client-width-height@2x.png b/2-ui/1-document/10-size-and-scroll-window/document-client-width-height@2x.png
index 249db0edb..868dc8a26 100644
Binary files a/2-ui/1-document/10-size-and-scroll-window/document-client-width-height@2x.png and b/2-ui/1-document/10-size-and-scroll-window/document-client-width-height@2x.png differ
diff --git a/2-ui/1-document/11-coordinates/article.md b/2-ui/1-document/11-coordinates/article.md
index ac5978f12..61b5161eb 100644
--- a/2-ui/1-document/11-coordinates/article.md
+++ b/2-ui/1-document/11-coordinates/article.md
@@ -48,7 +48,7 @@ Also:
 
 - Coordinates may be decimal fractions. That's normal, internally browser uses them for calculations. We don't have to round them when setting to `style.position.left/top`, the browser is fine with fractions.
 - Coordinates may be negative. For instance, if the page is scrolled down and the top `elem` is now above the window. Then, `elem.getBoundingClientRect().top` is negative.
-- Some browsers (like Chrome) provide additional properties (`width` and `height`) to `getBoundingClientRect` as the result. We can also get them by subtraction: `height=bottom-top`, `width=right-left`.
+- Some browsers (like Chrome) provide additional properties, `width` and `height` of the element that invoked the method to `getBoundingClientRect` as the result. We can also get them by subtraction: `height=bottom-top`, `width=right-left`.
 
 ```warn header="Coordinates right/bottom are different from CSS properties"
 If we compare window coordinates versus CSS positioning, then there are obvious similarities to `position:fixed`. The positioning of an element is also relative to the viewport.
diff --git a/2-ui/1-document/11-coordinates/coords.png b/2-ui/1-document/11-coordinates/coords.png
index da4869fb9..79d1fdbb6 100644
Binary files a/2-ui/1-document/11-coordinates/coords.png and b/2-ui/1-document/11-coordinates/coords.png differ
diff --git a/2-ui/1-document/11-coordinates/coords@2x.png b/2-ui/1-document/11-coordinates/coords@2x.png
index c3469f4cd..d3e340f50 100644
Binary files a/2-ui/1-document/11-coordinates/coords@2x.png and b/2-ui/1-document/11-coordinates/coords@2x.png differ
diff --git a/2-ui/1-document/11-coordinates/document-window-coordinates-scroll.png b/2-ui/1-document/11-coordinates/document-window-coordinates-scroll.png
index 9e4d9d5e9..29c59aad1 100644
Binary files a/2-ui/1-document/11-coordinates/document-window-coordinates-scroll.png and b/2-ui/1-document/11-coordinates/document-window-coordinates-scroll.png differ
diff --git a/2-ui/1-document/11-coordinates/document-window-coordinates-scroll@2x.png b/2-ui/1-document/11-coordinates/document-window-coordinates-scroll@2x.png
index 52e555c49..3c188ee45 100644
Binary files a/2-ui/1-document/11-coordinates/document-window-coordinates-scroll@2x.png and b/2-ui/1-document/11-coordinates/document-window-coordinates-scroll@2x.png differ
diff --git a/2-ui/1-document/11-coordinates/document-window-coordinates-zero.png b/2-ui/1-document/11-coordinates/document-window-coordinates-zero.png
index 3624196b0..3dc17f025 100644
Binary files a/2-ui/1-document/11-coordinates/document-window-coordinates-zero.png and b/2-ui/1-document/11-coordinates/document-window-coordinates-zero.png differ
diff --git a/2-ui/1-document/11-coordinates/document-window-coordinates-zero@2x.png b/2-ui/1-document/11-coordinates/document-window-coordinates-zero@2x.png
index 83f31950c..45f6b9e7f 100644
Binary files a/2-ui/1-document/11-coordinates/document-window-coordinates-zero@2x.png and b/2-ui/1-document/11-coordinates/document-window-coordinates-zero@2x.png differ
diff --git a/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/move-ball-coords.png b/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/move-ball-coords.png
index ca2f49edb..4a0549582 100644
Binary files a/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/move-ball-coords.png and b/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/move-ball-coords.png differ
diff --git a/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/move-ball-coords@2x.png b/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/move-ball-coords@2x.png
index b4c4d3ef2..ecf4e5d2f 100644
Binary files a/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/move-ball-coords@2x.png and b/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/move-ball-coords@2x.png differ
diff --git a/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/solution.md b/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/solution.md
index 8312f0391..bda48e2bb 100644
--- a/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/solution.md
+++ b/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/solution.md
@@ -33,7 +33,7 @@ We have `event.clientX/clientY` -- window-relative coordinates of the click.
 To get field-relative `left` coordinate of the click, we can substract the field left edge and the border width:
 
 ```js
-let left = event.clientX - fieldInnerCoords.left - field.clientLeft;
+let left = event.clientX - fieldCoords.left - field.clientLeft;
 ```
 
 Normally, `ball.style.position.left` means the "left edge of the element" (the ball). So if we assign that `left`, then the ball edge would be under the mouse cursor.
@@ -43,7 +43,7 @@ We need to move the ball half-width left and half-height up to make it center.
 So the final `left` would be:
 
 ```js
-let left = event.clientX - fieldInnerCoords.left - field.clientLeft - ball.offsetWidth/2;
+let left = event.clientX - fieldCoords.left - field.clientLeft - ball.offsetWidth/2;
 ```
 
 The vertical coordinate is calculated using the same logic.
diff --git a/2-ui/2-events/01-introduction-browser-events/05-sliding-menu/solution.md b/2-ui/2-events/01-introduction-browser-events/05-sliding-menu/solution.md
index f4c105941..eed096231 100644
--- a/2-ui/2-events/01-introduction-browser-events/05-sliding-menu/solution.md
+++ b/2-ui/2-events/01-introduction-browser-events/05-sliding-menu/solution.md
@@ -2,9 +2,9 @@
 # HTML/CSS
 First let's create HTML/CSS.
 
-A menu is a standalone graphical component on the page, so its better to put it into a single DOM element.
+A menu is a standalone graphical component on the page, so it's better to put it into a single DOM element.
 
-A list of menu items can be layed out as a list `ul/li`.
+A list of menu items can be laid out as a list `ul/li`.
 
 Here's the example structure:
 
diff --git a/2-ui/2-events/01-introduction-browser-events/05-sliding-menu/task.md b/2-ui/2-events/01-introduction-browser-events/05-sliding-menu/task.md
index 05af13cca..34c313710 100644
--- a/2-ui/2-events/01-introduction-browser-events/05-sliding-menu/task.md
+++ b/2-ui/2-events/01-introduction-browser-events/05-sliding-menu/task.md
@@ -2,7 +2,7 @@ importance: 5
 
 ---
 
-# Create a menu sliding menu
+# Create a sliding menu
 
 Create a menu that opens/collapses on click:
 
diff --git a/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel1.png b/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel1.png
index b58ac0a66..93defb0bb 100644
Binary files a/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel1.png and b/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel1.png differ
diff --git a/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel1@2x.png b/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel1@2x.png
index fe6a0badd..7aa0d0f84 100644
Binary files a/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel1@2x.png and b/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel1@2x.png differ
diff --git a/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel2.png b/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel2.png
index 351ead9c4..a61bf5e57 100644
Binary files a/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel2.png and b/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel2.png differ
diff --git a/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel2@2x.png b/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel2@2x.png
index 05dbc1adf..4742579db 100644
Binary files a/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel2@2x.png and b/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel2@2x.png differ
diff --git a/2-ui/2-events/01-introduction-browser-events/article.md b/2-ui/2-events/01-introduction-browser-events/article.md
index dcf64a200..332d15793 100644
--- a/2-ui/2-events/01-introduction-browser-events/article.md
+++ b/2-ui/2-events/01-introduction-browser-events/article.md
@@ -18,7 +18,7 @@ Here's a list of the most useful DOM events, just to take a look at:
 **Keyboard events:**
 - `keydown` and `keyup` -- when the visitor presses and then releases the button.
 
-**Document events**
+**Document events:**
 - `DOMContentLoaded` -- when the HTML is loaded and processed, DOM is fully built.
 
 **CSS events:**
@@ -216,7 +216,7 @@ Web-standard developers understood that long ago and suggested an alternative wa
 The syntax to add a handler:
 
 ```js
-element.addEventListener(event, handler[, phase]);
+element.addEventListener(event, handler[, options]);
 ```
 
 `event`
@@ -225,15 +225,17 @@ element.addEventListener(event, handler[, phase]);
 `handler`
 : The handler function.
 
-`phase`
-: An optional argument, the "phase" for the handler to work. To be covered later. Usually we don't use it.
+`options`
+: An additional optional object with properties:
+    - `once`: if `true`, then the listener is automatically removed after it triggers.
+    - `capture`: the phrase where to handle the event, to be covered later in the chapter <info:bubbling-and-capturing>. For historical reasons, `options` can also be `false/true`, that's the same as `{capture: false/true}`.
+    - `passive`: if `true`, then the handler will not `preventDefault()`, we'll cover that later in <info:default-browser-action>.
 
-To remove the handler, use `removeEventListener`:
 
+To remove the handler, use `removeEventListener`:
 
 ```js
-// exactly the same arguments as addEventListener
-element.removeEventListener(event, handler[, phase]);
+element.removeEventListener(event, handler[, options]);
 ```
 
 ````warn header="Removal requires the same function"
diff --git a/2-ui/2-events/02-bubbling-and-capturing/article.md b/2-ui/2-events/02-bubbling-and-capturing/article.md
index 287f74f2a..82ec8a84a 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -108,7 +108,7 @@ Sometimes `event.stopPropagation()` creates hidden pitfalls that later may becom
 
 For instance:
 
-1. We create a nested menu. Each submenu handles clicks on its elements and calls `stopPropagation` so that outer menu don't trigger.
+1. We create a nested menu. Each submenu handles clicks on its elements and calls `stopPropagation` so that the outer menu won't trigger.
 2. Later we decide to catch clicks on the whole window, to track users' behavior (where people click). Some analytic systems do that. Usually the code uses `document.addEventListener('click'…)` to catch all clicks.
 3. Our analytic won't work over the area where clicks are stopped by `stopPropagation`. We've got a "dead zone".
 
@@ -136,9 +136,15 @@ That is: for a click on `<td>` the event first goes through the ancestors chain
 
 Handlers added using `on<event>`-property or using HTML attributes or using `addEventListener(event, handler)` don't know anything about capturing, they only run on the 2nd and 3rd phases.
 
-To catch an event on the capturing phase, we need to set the 3rd argument of `addEventListener` to `true`.
+To catch an event on the capturing phase, we need to set the handler `capture` option to `true`:
 
-There are two possible values for that optional last argument:
+```js
+elem.addEventListener(..., {capture: true})
+// or, just "true" is an alias to {capture: true}
+elem.addEventListener(..., true)
+```
+
+There are two possible values of the `capture` option:
 
 - If it's `false` (default), then the handler is set on the bubbling phase.
 - If it's `true`, then the handler is set on the capturing phase.
@@ -182,12 +188,16 @@ Please note that `P` shows up two times: at the end of capturing and at the star
 
 There's a property `event.eventPhase` that tells us the number of the phase on which the event was caught. But it's rarely used, because we usually know it in the handler.
 
+```smart header="To remove the handler, `removeEventListener` needs the same phase"
+If we `addEventListener(..., true)`, then we should mention the same phase in `removeEventListener(..., true)` to correctly remove the handler.
+```
+
 ## Summary
 
 The event handling process:
 
 - When an event happens -- the most nested element where it happens gets labeled as the "target element" (`event.target`).
-- Then the event first moves from the document root down to the `event.target`, calling handlers assigned with `addEventListener(...., true)` on the way.
+- Then the event first moves from the document root down to the `event.target`, calling handlers assigned with `addEventListener(...., true)` on the way (`true` is a shorthand for `{capture: true}`).
 - Then the event moves from `event.target` up to the root, calling handlers assigned using  `on<event>` and `addEventListener` without the 3rd argument or with the 3rd argument `false`.
 
 Each handler can access `event` object properties:
diff --git a/2-ui/2-events/02-bubbling-and-capturing/event-order-bubbling.png b/2-ui/2-events/02-bubbling-and-capturing/event-order-bubbling.png
index a4f4fae51..9de1f2048 100644
Binary files a/2-ui/2-events/02-bubbling-and-capturing/event-order-bubbling.png and b/2-ui/2-events/02-bubbling-and-capturing/event-order-bubbling.png differ
diff --git a/2-ui/2-events/02-bubbling-and-capturing/event-order-bubbling@2x.png b/2-ui/2-events/02-bubbling-and-capturing/event-order-bubbling@2x.png
index e3a070cb8..81bb24c70 100644
Binary files a/2-ui/2-events/02-bubbling-and-capturing/event-order-bubbling@2x.png and b/2-ui/2-events/02-bubbling-and-capturing/event-order-bubbling@2x.png differ
diff --git a/2-ui/2-events/02-bubbling-and-capturing/eventflow.png b/2-ui/2-events/02-bubbling-and-capturing/eventflow.png
index 95c5c08e0..56fa230a6 100644
Binary files a/2-ui/2-events/02-bubbling-and-capturing/eventflow.png and b/2-ui/2-events/02-bubbling-and-capturing/eventflow.png differ
diff --git a/2-ui/2-events/02-bubbling-and-capturing/eventflow@2x.png b/2-ui/2-events/02-bubbling-and-capturing/eventflow@2x.png
index d52c4f70c..17ab1bf8e 100644
Binary files a/2-ui/2-events/02-bubbling-and-capturing/eventflow@2x.png and b/2-ui/2-events/02-bubbling-and-capturing/eventflow@2x.png differ
diff --git a/2-ui/2-events/03-event-delegation/bagua-bubble.png b/2-ui/2-events/03-event-delegation/bagua-bubble.png
index f0433aeb1..55adbd0c1 100644
Binary files a/2-ui/2-events/03-event-delegation/bagua-bubble.png and b/2-ui/2-events/03-event-delegation/bagua-bubble.png differ
diff --git a/2-ui/2-events/03-event-delegation/bagua-bubble@2x.png b/2-ui/2-events/03-event-delegation/bagua-bubble@2x.png
index 8cc5ca913..86b6d6807 100644
Binary files a/2-ui/2-events/03-event-delegation/bagua-bubble@2x.png and b/2-ui/2-events/03-event-delegation/bagua-bubble@2x.png differ
diff --git a/2-ui/2-events/04-default-browser-action/article.md b/2-ui/2-events/04-default-browser-action/article.md
index b2889132f..44355de0d 100644
--- a/2-ui/2-events/04-default-browser-action/article.md
+++ b/2-ui/2-events/04-default-browser-action/article.md
@@ -93,6 +93,20 @@ But if you click the second one, there's no focus.
 
 That's because the browser action is canceled on `mousedown`. The focusing is still possible if we use another way to enter the input. For instance, the `key:Tab` key to switch from the 1st input into the 2nd. But not with the mouse click any more.
 
+## The "passive" handler option
+
+The optional `passive: true` option of `addEventListener` signals the browser that the handler is not going to call `preventDefault()`.
+
+Why that may be needed?
+
+There are some events like `touchmove` on mobile devices (when the user moves their finger across the screen), that cause scrolling by default, but that scrolling can be prevented using `preventDefault()` in the handler.
+
+So when the browser detects such event, it has first to process all handlers, and then if `preventDefault` is not called anywhere, it can proceed with scrolling. That may cause unnecessary delays and "jitters" in the UI.
+
+The `passive: true` options tells the browser that the handler is not going to cancel scrolling. Then browser scrolls immediately providing a maximally fluent experience, and the event is handled by the way.
+
+For some browsers (Firefox, Chrome), `passive` is `true` by default for `touchstart` and `touchmove` events.
+
 
 ## event.defaultPrevented
 
@@ -215,6 +229,8 @@ All the default actions can be prevented if we want to handle the event exclusiv
 
 To prevent a default action -- use either `event.preventDefault()` or  `return false`. The second method works only for handlers assigned with `on<event>`.
 
+The `passive: true` option of `addEventListener` tells the browser that the action is not going to be prevented. That's useful for some mobile events, like `touchstart` and `touchmove`, to tell the browser that it should not wait for all handlers to finish before scrolling.
+
 If the default action was prevented, the value of `event.defaultPrevented` becomes `true`, otherwise it's `false`.
 
 ```warn header="Stay semantic, don't abuse"
diff --git a/2-ui/2-events/05-dispatch-events/article.md b/2-ui/2-events/05-dispatch-events/article.md
index 8b37edae7..2b13d2360 100644
--- a/2-ui/2-events/05-dispatch-events/article.md
+++ b/2-ui/2-events/05-dispatch-events/article.md
@@ -148,7 +148,7 @@ For instance:
 *!*
     detail: { name: "John" }
 */!*
-  });
+  }));
 </script>
 ```
 
diff --git a/2-ui/2-events/index.md b/2-ui/2-events/index.md
index 07f06fdda..f4996083c 100644
--- a/2-ui/2-events/index.md
+++ b/2-ui/2-events/index.md
@@ -1,3 +1,3 @@
-# Introduction into Events
+# Introduction to Events
 
 An introduction to browser events, event properties and handling patterns.
diff --git a/2-ui/3-event-details/11-onload-onerror/article.md b/2-ui/3-event-details/11-onload-onerror/article.md
deleted file mode 100644
index 7792626c7..000000000
--- a/2-ui/3-event-details/11-onload-onerror/article.md
+++ /dev/null
@@ -1,91 +0,0 @@
-# Resource loading: onload and onerror
-
-The browser allows to track the loading of external resources -- scripts, iframes, pictures and so on.
-
-There are two events for it:
-
-- `onload` -- successful load,
-- `onerror` -- an error occurred.
-
-## Loading a script
-
-Let's say we need to call a function that resides in an external script.
-
-We can load it dynamically, like this:
-
-```js
-let script = document.createElement('script');
-script.src = "my.js";
-
-document.head.append(script);
-```
-
-...But how to run the function that is declared inside that script? We need to wait until the script loads, and only then we can call it.
-
-### script.onload
-
-The main helper is the `load` event. It triggers after the script was loaded and executed.
-
-For instance:
-
-```js run untrusted
-let script = document.createElement('script');
-
-// can load any script, from any domain
-script.src = "https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.3.0/lodash.js"
-document.head.append(script);
-
-*!*
-script.onload = function() {
-  // the script creates a helper function "_"
-  alert(_); // the function is available
-};
-*/!*
-```
-
-So in `onload` we can use script variables, run functions etc.
-
-...And what if the loading failed? For instance, there's no such script (error 404) or the server or the server is down (unavailable).
-
-### script.onerror
-
-Errors that occur during the loading (but not execution) of the script can be tracked on `error` event.
-
-For instance, let's request a script that doesn't exist:
-
-```js run
-let script = document.createElement('script');
-script.src = "https://example.com/404.js"; // no such script
-document.head.append(script);
-
-*!*
-script.onerror = function() {
-  alert("Error loading " + this.src); // Error loading https://example.com/404.js
-};
-*/!*
-```
-
-Please note that we can't get error details here. We don't know was it error 404 or 500 or something else. Just that the loading failed.
-
-## Other resources
-
-The `load` and `error` events also work for other resources. There may be minor differences though.
-
-For instance:
-
-`<img>`, `<link>` (external stylesheets)
-: Both `load` and `error` events work as expected.
-
-`<iframe>`
-: Only `load` event when the iframe loading finished. It triggers both for successful load and in case of an error. That's for historical reasons.
-
-## Summary
-
-Pictures `<img>`, external styles, scripts and other resources provide `load` and `error` events to track their loading:
-
-- `load` triggers on a successful load,
-- `error` triggers on a failed load.
-
-The only exception is `<iframe>`: for historical reasons it always triggers `load`, for any load completion, even if the page is not found.
-
-The `readystatechange` event also works for resources, but is rarely used, because `load/error` events are simpler.
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/article.md b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/article.md
index 25bd3856d..f60d7e63e 100644
--- a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/article.md
+++ b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/article.md
@@ -50,7 +50,7 @@ If the mouse moves very fast from `#FROM` to `#TO` elements as painted above, th
 
 In practice that's helpful, because if there may be many intermediate elements. We don't really want to process in and out of each one.
 
-From the other side, we should keep in mind that we can't assume that the mouse slowly moves from one event to another. No, it can "jump".
+On the other hand, we should keep in mind that we can't assume that the mouse slowly moves from one event to another. No, it can "jump".
 
 In particular it's possible that the cursor jumps right inside the middle of the page from out of the window. And `relatedTarget=null`, because it came from "nowhere":
 
@@ -96,7 +96,7 @@ Try entering the blue element and then moving the mouse on the red one -- and wa
 
 So, for a handler that does not take `target` into account, it looks like we left the parent in `mouseout` in `(2)` and returned back to it by `mouseover` in `(3)`.
 
-If we perform some actions on entering/leaving the element, then we'll get a lot of extra "false" runs. For simple stuff may be unnoticeable. For complex things that may bring unwanted side-effects.
+If we perform some actions on entering/leaving the element, then we'll get a lot of extra "false" runs. For simple stuff that may be unnoticeable. For complex things that may bring unwanted side-effects.
 
 We can fix it by using `mouseenter/mouseleave` events instead.
 
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout-from-outside.png b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout-from-outside.png
index ea5723307..a9d76bebf 100644
Binary files a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout-from-outside.png and b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout-from-outside.png differ
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout-from-outside@2x.png b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout-from-outside@2x.png
index 6a17ca99f..8ef27b83a 100644
Binary files a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout-from-outside@2x.png and b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout-from-outside@2x.png differ
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout-over-elems.png b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout-over-elems.png
index babbea502..f4b3dfe8e 100644
Binary files a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout-over-elems.png and b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout-over-elems.png differ
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout-over-elems@2x.png b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout-over-elems@2x.png
index e61891a5a..0c95cc30c 100644
Binary files a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout-over-elems@2x.png and b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout-over-elems@2x.png differ
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout.png b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout.png
index e82adf50e..e386c5caf 100644
Binary files a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout.png and b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout.png differ
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout@2x.png b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout@2x.png
index b1c567e97..a49caf310 100644
Binary files a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout@2x.png and b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout@2x.png differ
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-to-child.png b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-to-child.png
index 25102e06a..975acf4af 100644
Binary files a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-to-child.png and b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-to-child.png differ
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-to-child@2x.png b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-to-child@2x.png
index 22aebe24c..50725f39c 100644
Binary files a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-to-child@2x.png and b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-to-child@2x.png differ
diff --git a/2-ui/3-event-details/4-mouse-drag-and-drop/2-drag-heroes/solution.view/soccer.js b/2-ui/3-event-details/4-mouse-drag-and-drop/2-drag-heroes/solution.view/soccer.js
index 6c3daa5b2..1c1443a7e 100644
--- a/2-ui/3-event-details/4-mouse-drag-and-drop/2-drag-heroes/solution.view/soccer.js
+++ b/2-ui/3-event-details/4-mouse-drag-and-drop/2-drag-heroes/solution.view/soccer.js
@@ -1,3 +1,5 @@
+let isDragging = false;
+
 document.addEventListener('mousedown', function(event) {
 
   let dragElement = event.target.closest('.draggable');
@@ -5,16 +7,19 @@ document.addEventListener('mousedown', function(event) {
   if (!dragElement) return;
 
   event.preventDefault();
-  let coords, shiftX, shiftY;
+  
+  dragElement.ondragstart = function() {
+      return false;
+  };
 
-  startDrag(event.clientX, event.clientY);
+  let coords, shiftX, shiftY;
 
-  document.addEventListener('mousemove', onMouseMove);
+  startDrag(dragElement, event.clientX, event.clientY);
 
-  dragElement.onmouseup = function() {
+  function onMouseUp(event) {
     finishDrag();
   };
-
+  
   function onMouseMove(event) {
     moveAt(event.clientX, event.clientY);
   }
@@ -22,25 +27,37 @@ document.addEventListener('mousedown', function(event) {
   // on drag start:
   //   remember the initial shift
   //   move the element position:fixed and a direct child of body
-  function startDrag(clientX, clientY) {
-
-    shiftX = clientX - dragElement.getBoundingClientRect().left;
-    shiftY = clientY - dragElement.getBoundingClientRect().top;
+  function startDrag(element, clientX, clientY) {
+    if(isDragging) {
+      return;
+    }
+    
+    isDragging = true;
+    
+    document.addEventListener('mousemove', onMouseMove);
+    element.addEventListener('mouseup', onMouseUp);
 
-    dragElement.style.position = 'fixed';
+    shiftX = clientX - element.getBoundingClientRect().left;
+    shiftY = clientY - element.getBoundingClientRect().top;
 
-    document.body.append(dragElement);
+    element.style.position = 'fixed';
 
     moveAt(clientX, clientY);
   };
 
   // switch to absolute coordinates at the end, to fix the element in the document
   function finishDrag() {
+    if(!isDragging) {
+      return;
+    }
+    
+    isDragging = false;
+
     dragElement.style.top = parseInt(dragElement.style.top) + pageYOffset + 'px';
     dragElement.style.position = 'absolute';
 
     document.removeEventListener('mousemove', onMouseMove);
-    dragElement.onmouseup = null;
+    dragElement.removeEventListener('mouseup', onMouseUp);
   }
 
   function moveAt(clientX, clientY) {
@@ -96,4 +113,4 @@ document.addEventListener('mousedown', function(event) {
     dragElement.style.top = newY + 'px';
   }
 
-});
+});
\ No newline at end of file
diff --git a/2-ui/3-event-details/4-mouse-drag-and-drop/article.md b/2-ui/3-event-details/4-mouse-drag-and-drop/article.md
index e8126f5bc..6390b392a 100644
--- a/2-ui/3-event-details/4-mouse-drag-and-drop/article.md
+++ b/2-ui/3-event-details/4-mouse-drag-and-drop/article.md
@@ -15,7 +15,7 @@ So here we'll see how to implement Drag'n'Drop using mouse events. Not that hard
 The basic Drag'n'Drop algorithm looks like this:
 
 1. Catch `mousedown` on a draggable element.
-2. Prepare the element to moving (maybe create a copy of it or whatever).
+2. Prepare the element for moving (maybe create a copy of it or whatever).
 3. Then on `mousemove` move it by changing `left/top` and `position:absolute`.
 4. On `mouseup` (button release) -- perform all actions related to a finished Drag'n'Drop.
 
@@ -58,7 +58,7 @@ ball.onmousedown = function(event) { // (1) start the process
 };
 ```
 
-If we run the code, we can notice something strange. On the beginning of the drag'n'drop, the ball "forks": we start to dragging it's "clone".
+If we run the code, we can notice something strange. On the beginning of the drag'n'drop, the ball "forks": we start dragging its "clone".
 
 ```online
 Here's an example in action:
@@ -178,7 +178,7 @@ In action (inside `<iframe>`):
 [iframe src="ball3" height=230]
 ```
 
-The difference is especially noticeable if we drag the ball by it's right-bottom corner. In the previous example the ball "jumps" under the pointer. Now it fluently follows the cursor from the current position.
+The difference is especially noticeable if we drag the ball by its right-bottom corner. In the previous example the ball "jumps" under the pointer. Now it fluently follows the cursor from the current position.
 
 ## Detecting droppables
 
diff --git a/2-ui/3-event-details/index.md b/2-ui/3-event-details/index.md
index f5d7ca8b8..569f08137 100644
--- a/2-ui/3-event-details/index.md
+++ b/2-ui/3-event-details/index.md
@@ -1,3 +1,3 @@
-# Events in details
+# UI Events
 
-Here we cover most important events and details of working with them.
+Here we cover most important user interface events and how to work with them.
diff --git a/2-ui/4-forms-controls/1-form-elements/form-navigation.png b/2-ui/4-forms-controls/1-form-elements/form-navigation.png
index 5d00632b2..1ee86a4b1 100644
Binary files a/2-ui/4-forms-controls/1-form-elements/form-navigation.png and b/2-ui/4-forms-controls/1-form-elements/form-navigation.png differ
diff --git a/2-ui/4-forms-controls/1-form-elements/form-navigation@2x.png b/2-ui/4-forms-controls/1-form-elements/form-navigation@2x.png
index 1997b2b36..7a36f3a87 100644
Binary files a/2-ui/4-forms-controls/1-form-elements/form-navigation@2x.png and b/2-ui/4-forms-controls/1-form-elements/form-navigation@2x.png differ
diff --git a/2-ui/4-forms-controls/2-focus-blur/3-editable-div/task.md b/2-ui/4-forms-controls/2-focus-blur/3-editable-div/task.md
index 2a5a6a9b2..8e45bfa86 100644
--- a/2-ui/4-forms-controls/2-focus-blur/3-editable-div/task.md
+++ b/2-ui/4-forms-controls/2-focus-blur/3-editable-div/task.md
@@ -8,6 +8,6 @@ Create a `<div>` that turns into `<textarea>` when clicked.
 
 The textarea allows to edit the HTML in the `<div>`.
 
-When the user presses `key:Enter` or it looses focus, the `<textarea>` turns back into `<div>`, and its content becomes HTML in `<div>`.
+When the user presses `key:Enter` or it loses focus, the `<textarea>` turns back into `<div>`, and its content becomes HTML in `<div>`.
 
 [demo src="solution"]
diff --git a/2-ui/4-forms-controls/2-focus-blur/article.md b/2-ui/4-forms-controls/2-focus-blur/article.md
index 3177ee39a..1a880ce47 100644
--- a/2-ui/4-forms-controls/2-focus-blur/article.md
+++ b/2-ui/4-forms-controls/2-focus-blur/article.md
@@ -49,7 +49,7 @@ Your email please: <input type="email" id="input">
 </script>
 ```
 
-Modern HTML allows to do many validations using input attributes: `required`, `pattern` and so on. And sometimes they are just what we need. JavaScript can be used when we want more flexibility. Also we could automatically send the changed value on the server if it's correct.
+Modern HTML allows to do many validations using input attributes: `required`, `pattern` and so on. And sometimes they are just what we need. JavaScript can be used when we want more flexibility. Also we could automatically send the changed value to the server if it's correct.
 
 
 ## Methods focus/blur
@@ -100,7 +100,7 @@ One of them is when the visitor clicks somewhere else. But also JavaScript itsel
 
 These features sometimes cause `focus/blur` handlers to misbehave -- to trigger when they are not needed.
 
-The best recipe is to be careful when using these events. If we want to track user-initiated focus-loss, then we should evade causing it by ourselves.
+The best recipe is to be careful when using these events. If we want to track user-initiated focus-loss, then we should avoid causing it ourselves.
 ```
 ## Allow focusing on any element: tabindex
 
diff --git a/2-ui/4-forms-controls/3-events-change-input/article.md b/2-ui/4-forms-controls/3-events-change-input/article.md
index 2b46b0835..b6247198d 100644
--- a/2-ui/4-forms-controls/3-events-change-input/article.md
+++ b/2-ui/4-forms-controls/3-events-change-input/article.md
@@ -6,7 +6,7 @@ Let's discuss various events that accompany data updates.
 
 The [change](http://www.w3.org/TR/html5/forms.html#event-input-change) event triggers when the element has finished changing.
 
-For text inputs that means that the event occurs when it looses focus.
+For text inputs that means that the event occurs when it loses focus.
 
 For instance, while we are typing in the text field below -- there's no event. But when we move the focus somewhere else, for instance, click on a button -- there will be a `change` event:
 
@@ -62,7 +62,7 @@ For instance, the code below prevents all such events and shows what we are tryi
 </script>
 ```
 
-Technically, we can copy/paste everything. For instance, we can copy and file in the OS file manager, and paste it.
+Technically, we can copy/paste everything. For instance, we can copy a file in the OS file manager, and paste it.
 
 There's a list of methods [in the specification](https://www.w3.org/TR/clipboard-apis/#dfn-datatransfer) to work with different data types, read/write to the clipboard.
 
diff --git a/2-ui/3-event-details/10-onload-ondomcontentloaded/article.md b/2-ui/5-loading/01-onload-ondomcontentloaded/article.md
similarity index 56%
rename from 2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
rename to 2-ui/5-loading/01-onload-ondomcontentloaded/article.md
index 7c62da197..2d60aa1d3 100644
--- a/2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
+++ b/2-ui/5-loading/01-onload-ondomcontentloaded/article.md
@@ -1,4 +1,4 @@
-# Page lifecycle: DOMContentLoaded, load, beforeunload, unload
+# Page: DOMContentLoaded, load, beforeunload, unload
 
 The lifecycle of an HTML page has three important events:
 
@@ -10,7 +10,8 @@ Each event may be useful:
 
 - `DOMContentLoaded` event -- DOM is ready, so the handler can lookup DOM nodes, initialize the interface.
 - `load` event -- additional resources are loaded, we can get image sizes (if not specified in HTML/CSS) etc.
-- `beforeunload/unload` event -- the user is leaving: we can check if the user saved the changes and ask them whether they really want to leave.
+- `beforeunload` event -- the user is leaving: we can check if the user saved the changes and ask them whether they really want to leave.
+- `unload` -- the user almost left, but we still can initiate some operations, such as sending out statistics.
 
 Let's explore the details of these events.
 
@@ -22,6 +23,7 @@ We must use `addEventListener` to catch it:
 
 ```js
 document.addEventListener("DOMContentLoaded", ready);
+// not "document.onDOMContentLoaded = ..."
 ```
 
 For instance:
@@ -43,40 +45,46 @@ For instance:
 <img id="img" src="https://en.js.cx/clipart/train.gif?speed=1&cache=0">
 ```
 
-In the example the `DOMContentLoaded` handler runs when the document is loaded and does not wait for the image to load. So `alert` shows zero sizes.
+In the example the `DOMContentLoaded` handler runs when the document is loaded, so it can see all the elements, including `<img>` below.
 
-At the first sight `DOMContentLoaded` event is very simple. The DOM tree is ready -- here's the event. But there are few peculiarities.
+But it doesn't wait for the image to load. So `alert` shows zero sizes.
 
-### DOMContentLoaded and scripts
+At the first sight `DOMContentLoaded` event is very simple. The DOM tree is ready -- here's the event. There are few peculiarities though.
 
-When the browser initially loads HTML and comes across a `<script>...</script>` in the text, it can't continue building DOM. It must execute the script right now. So `DOMContentLoaded` may only happen after all such scripts are executed.
+### DOMContentLoaded and scripts
 
-External scripts (with `src`) also put DOM building to pause while the script is loading and executing. So `DOMContentLoaded` waits for external scripts as well.
+When the browser processes an HTML-document and comes across a `<script>` tag, it needs to execute before continuing building the DOM. That's a precaution, as scripts may want to modify DOM, and even `document.write` into it, so `DOMContentLoaded` has to wait.
 
-The only exception are external scripts with `async` and `defer` attributes. They tell the browser to continue processing without waiting for the scripts. This lets the user see the page before scripts finish loading, which is good for performance.
+So DOMContentLoaded definitely happens after such scripts:
 
-### Scripts with `async` and `defer`
+```html run
+<script>
+  document.addEventListener("DOMContentLoaded", () => {
+    console.log("DOM ready!");
+  });
+</script>
 
-Attributes `async` and `defer` work only for external scripts. They are ignored if there's no `src`.
+<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.3.0/lodash.js"></script>
 
-Both of them tell the browser that it may go on working with the page, and load the script "in background", then run the script when it loads. So the script doesn't block DOM building and page rendering.
+<script>
+  alert("Library loaded, inline script executed");
+</script>
+```
 
-There are two differences between them.
+In the example above, we first see "Library loaded...", and then "DOM ready!" (all scripts are executed).
 
-|         | `async` | `defer` |
-|---------|---------|---------|
-| Order | Scripts with `async` execute *in the load-first order*. Their document order doesn't matter -- which loads first runs first. | Scripts with `defer` always execute *in the document order* (as they go in the document). |
-| `DOMContentLoaded` | Scripts with `async` may load and execute while the document has not yet been fully downloaded. That happens if scripts are small or cached, and the document is long enough. | Scripts with `defer` execute after the document is loaded and parsed (they wait if needed), right before `DOMContentLoaded`. |
+```warn header="Scripts with `async`, `defer` or `type=\"module\"` don't block DOMContentLoaded"
 
-So `async` is used for independent scripts, like counters or ads, that don't need to access page content. And their relative execution order does not matter.
+Script attributes `async` and `defer`, that we'll cover [a bit later](info:script-async-defer), don't block DOMContentLoaded. [JavaScript modules](info:modules) behave like `defer`,  they don't block it too.
 
-While `defer` is used for scripts that need DOM and/or their relative execution order is important.
+So here we're talking about "regular" scripts, like `<script>...</script>`, or `<script src="..."></script>`.
+```
 
 ### DOMContentLoaded and styles
 
-External style sheets don't affect DOM, and so `DOMContentLoaded` does not wait for them.
+External style sheets don't affect DOM, so `DOMContentLoaded` does not wait for them.
 
-But there's a pitfall: if we have a script after the style, then that script must wait for the stylesheet to execute:
+But there's a pitfall. If we have a script after the style, then that script must wait until the stylesheet loads:
 
 ```html
 <link type="text/css" rel="stylesheet" href="style.css">
@@ -98,7 +106,6 @@ For instance, if the page has a form with login and password, and the browser re
 
 So if `DOMContentLoaded` is postponed by long-loading scripts, then autofill also awaits. You probably saw that on some sites (if you use browser autofill) -- the login/password fields don't get autofilled immediately, but there's a delay till the page fully loads. That's actually the delay until the `DOMContentLoaded` event.
 
-One of minor benefits in using `async` and `defer` for external scripts -- they don't block `DOMContentLoaded` and don't delay browser autofill.
 
 ## window.onload [#window-onload]
 
@@ -121,39 +128,75 @@ The example below correctly shows image sizes, because `window.onload` waits for
 
 ## window.onunload
 
-When a visitor leaves the page, the `unload` event triggers on `window`. We can do something there that doesn't involve a delay, like closing related popup windows. But we can't cancel the transition to another page.
+When a visitor leaves the page, the `unload` event triggers on `window`. We can do something there that doesn't involve a delay, like closing related popup windows.
+
+The notable exception is sending analytics.
+
+Let's say we gather data about how the page is used: mouse clicks, scrolls, viewed page areas, and so on.
+
+Naturally, `unload` event is when the user leaves us, and we'd like to save the data on our server.
+
+There exists a special `navigator.sendBeacon(url, data)` method for such needs, described in the specification <https://w3c.github.io/beacon/>.
+
+It sends the data in background. The transition to another page is not delayed: the browser leaves the page, but still performs `sendBeacon`.
+
+Here's how to use it:
+```js
+let analyticsData = { /* object with gathered data */ };
+
+window.addEventListener("unload", function() {
+  navigator.sendBeacon("/analytics", JSON.stringify(analyticsData));
+};
+```
+
+- The request is sent as POST.
+- We can send not only a string, but also forms and other formats, as described in the chapter <info:fetch-basics>, but usually it's a stringified object.
+- The data is limited by 64kb.
 
-For that we should use another event -- `onbeforeunload`.
+When the `sendBeacon` request is finished, the browser probably has already left the document, so there's no way to get server response (which is usually empty for analytics).
+
+There's also a `keepalive` flag for doing such "after-page-left" requests in  [fetch](info:fetch-basics) method for generic network requests. You can find more information in the chapter <info:fetch-api>.
+
+
+If we want to cancel the transition to another page, we can't do it here. But we can use  another event -- `onbeforeunload`.
 
 ## window.onbeforeunload [#window.onbeforeunload]
 
 If a visitor initiated navigation away from the page or tries to close the window, the `beforeunload` handler asks for additional confirmation.
 
-It may return a string with the question. Historically browsers used to show it, but as of now only some of them do. That's because certain webmasters abused this event handler by showing misleading and hackish messages.
+If we cancel the event, the browser may ask the visitor if they are sure.
 
-You can try it by running this code and then reloading the page.
+You can try it by running this code and then reloading the page:
 
 ```js run
 window.onbeforeunload = function() {
-  return "There are unsaved changes. Leave now?";
+  return false;
 };
 ```
 
-```online
-Or you can click on the button in `<iframe>` below to set the handler, and then click the link:
+For historical reasons, returning a non-empty string also counts as canceling the event. Some time ago browsers used show it as a message, but as the [modern specification](https://html.spec.whatwg.org/#unloading-documents) says, they shouldn't.
 
-[iframe src="window-onbeforeunload" border="1" height="80" link edit]
+Here's an example:
+
+```js run
+window.onbeforeunload = function() {
+  return "There are unsaved changes. Leave now?";
+};
 ```
 
+The behavior was changed, because some webmasters abused this event handler by showing misleading and annoying messages. So right now old browsers still may show it as a message, but aside of that -- there's no way to customize the message shown to the user.
+
 ## readyState
 
 What happens if we set the `DOMContentLoaded` handler after the document is loaded?
 
 Naturally, it never runs.
 
-There are cases when we are not sure whether the document is ready or not, for instance an external script with `async` attribute loads and runs asynchronously. Depending on the network, it may load and execute before the document is complete or after that, we can't be sure. So we should be able to know the current state of the document.
+There are cases when we are not sure whether the document is ready or not. We'd like our function to execute when the DOM is loaded, be it now or later.
+
+The `document.readyState` property tells us about the current loading state.
 
-The `document.readyState` property gives us information about it. There are 3 possible values:
+There are 3 possible values:
 
 - `"loading"` -- the document is loading.
 - `"interactive"` -- the document was fully read.
@@ -167,13 +210,15 @@ Like this:
 function work() { /*...*/ }
 
 if (document.readyState == 'loading') {
+  // loading yet, wait for the event
   document.addEventListener('DOMContentLoaded', work);
 } else {
+  // DOM is ready!
   work();
 }
 ```
 
-There's a `readystatechange` event that triggers when the state changes, so we can print all these states like this:
+There's also `readystatechange` event that triggers when the state changes, so we can print all these states like this:
 
 ```js run
 // current state
@@ -183,15 +228,14 @@ console.log(document.readyState);
 document.addEventListener('readystatechange', () => console.log(document.readyState));
 ```
 
-The `readystatechange` event is an alternative mechanics of tracking the document loading state, it appeared long ago. Nowadays, it is rarely used, but let's cover it for completeness.
+The `readystatechange` event is an alternative mechanics of tracking the document loading state, it appeared long ago. Nowadays, it is rarely used.
 
-What is the place of `readystatechange` among other events?
+Let's see the full events flow for the completeness.
 
-To see the timing, here's a document with `<iframe>`, `<img>` and handlers that log events:
+Here's a document with `<iframe>`, `<img>` and handlers that log events:
 
 ```html
 <script>
-  function log(text) { /* output the time and message */ }
   log('initial readyState:' + document.readyState);
 
   document.addEventListener('readystatechange', () => log('readyState:' + document.readyState));
@@ -219,23 +263,22 @@ The typical output:
 6. [4] readyState:complete
 7. [4] window onload
 
-The numbers in square brackets denote the approximate time of when it happens. The real time is a bit greater, but events labeled with the same digit happen approximately at the same time (+- a few ms).
+The numbers in square brackets denote the approximate time of when it happens. Events labeled with the same digit happen approximately at the same time (+- a few ms).
 
-- `document.readyState` becomes `interactive` right before `DOMContentLoaded`. These two events actually mean the same.
+- `document.readyState` becomes `interactive` right before `DOMContentLoaded`. These two things actually mean the same.
 - `document.readyState` becomes `complete` when all resources (`iframe` and `img`) are loaded. Here we can see that it happens in about the same time as `img.onload` (`img` is the last resource) and `window.onload`. Switching to `complete` state means the same as `window.onload`. The difference is that `window.onload` always works after all other `load` handlers.
 
 
-## Lifecycle events summary
+## Summary
 
-Page lifecycle events:
+Page load events:
 
 - `DOMContentLoaded` event triggers on `document` when DOM is ready. We can apply JavaScript to elements at this stage.
-  - All inline scripts and scripts with `defer` are already executed.
-  - Async scripts may execute both before and after the event, depends on when they load.
+  - Script such as `<script>...</script>` or `<script src="..."></script>` block DOMContentLoaded, the browser waits for them to execute.
   - Images and other resources may also still continue loading.
 - `load` event on `window` triggers when the page and all resources are loaded. We rarely use it, because there's usually no need to wait for so long.
-- `beforeunload` event on `window` triggers when the user wants to leave the page. If it returns a string, the browser shows a question whether the user really wants to leave or not.
-- `unload` event on `window` triggers when the user is finally leaving, in the handler we can only do simple things that do not involve delays or asking a user. Because of that limitation, it's rarely used.
+- `beforeunload` event on `window` triggers when the user wants to leave the page. If we cancel the event, browser asks whether the user really wants to leave (e.g we have unsaved changes).
+- `unload` event on `window` triggers when the user is finally leaving, in the handler we can only do simple things that do not involve delays or asking a user. Because of that limitation, it's rarely used. We can send out a network request with `navigator.sendBeacon`.
 - `document.readyState` is the current state of the document, changes can be tracked in the `readystatechange` event:
   - `loading` -- the document is loading.
   - `interactive` -- the document is parsed, happens at about the same time as `DOMContentLoaded`, but before it.
diff --git a/2-ui/3-event-details/10-onload-ondomcontentloaded/readystate.view/iframe.html b/2-ui/5-loading/01-onload-ondomcontentloaded/readystate.view/iframe.html
similarity index 100%
rename from 2-ui/3-event-details/10-onload-ondomcontentloaded/readystate.view/iframe.html
rename to 2-ui/5-loading/01-onload-ondomcontentloaded/readystate.view/iframe.html
diff --git a/2-ui/3-event-details/10-onload-ondomcontentloaded/readystate.view/index.html b/2-ui/5-loading/01-onload-ondomcontentloaded/readystate.view/index.html
similarity index 100%
rename from 2-ui/3-event-details/10-onload-ondomcontentloaded/readystate.view/index.html
rename to 2-ui/5-loading/01-onload-ondomcontentloaded/readystate.view/index.html
diff --git a/2-ui/3-event-details/10-onload-ondomcontentloaded/window-onbeforeunload.view/index.html b/2-ui/5-loading/01-onload-ondomcontentloaded/window-onbeforeunload.view/index.html
old mode 100755
new mode 100644
similarity index 100%
rename from 2-ui/3-event-details/10-onload-ondomcontentloaded/window-onbeforeunload.view/index.html
rename to 2-ui/5-loading/01-onload-ondomcontentloaded/window-onbeforeunload.view/index.html
diff --git a/2-ui/5-loading/02-script-async-defer/article.md b/2-ui/5-loading/02-script-async-defer/article.md
new file mode 100644
index 000000000..f5c3faeb1
--- /dev/null
+++ b/2-ui/5-loading/02-script-async-defer/article.md
@@ -0,0 +1,197 @@
+
+# Scripts: async, defer
+
+In modern websites, scripts are often "heavier" than HTML: their download size is larger, and processing time is also longer.
+
+When the browser loads HTML and comes across a `<script>...</script>` tag, it can't continue building DOM. It must execute the script right now. The same happens for external scripts `<script src="..."></script>`: the browser must wait until the script downloads, execute it, and only after process the rest of the page.
+
+That leads to two important issues:
+
+1. Scripts can't see DOM elements below them, so can't add handlers etc.
+2. If there's a bulky script at the top of the page, it "blocks the page". Users can't see the page content till it downloads and runs:
+
+```html run height=100
+<p>...content before script...</p>
+
+<script src="https://javascript.info/article/script-async-defer/long.js?speed=1"></script>
+
+<!-- This isn't visible until the script loads -->
+<p>...content after script...</p>
+```
+
+There are some workarounds to that. For instance, we can put a script at the bottom of the page. Then it can see elements above it, and it doesn't block the page content from showing:
+
+```html
+<body>
+  ...all content is above the script...
+
+  <script src="https://javascript.info/article/script-async-defer/long.js?speed=1"></script>
+</body>
+```
+
+But this solution is far from perfect. For example, the browser actually notices the script (and can start downloading it) only after it downloaded the full HTML document. For long HTML documents, that may be a noticeable delay.
+
+Such things are invisible for people using very fast connections, but many people in the world still have slower internet speeds and far-from-perfect mobile connectivity.
+
+Luckily, there are two `<script>` attributes that solve the problem for us: `defer` and `async`
+
+## defer
+
+The `defer` attribute tells the browser that it should go on working with the page, and load the script "in background", then run the script when it loads.
+
+Here's the same example as above, but with `defer`:
+
+```html run height=100
+<p>...content before script...</p>
+
+<script defer src="https://javascript.info/article/script-async-defer/long.js?speed=1"></script>
+
+<!-- visible immediately -->
+<p>...content after script...</p>
+```
+
+- Scripts with `defer` never block the page.
+- Scripts with `defer` always execute when the DOM is ready, but before `DOMContentLoaded` event.
+
+The following example demonstrates that:
+
+```html run height=100
+<p>...content before scripts...</p>
+
+<script>
+  document.addEventListener('DOMContentLoaded', () => alert("DOM ready after defer!")); // (2)
+</script>
+
+<script defer src="https://javascript.info/article/script-async-defer/long.js?speed=1"></script>
+
+<p>...content after scripts...</p>
+```
+
+1. The page content shows up immediately.
+2. `DOMContentLoaded` waits for the deferred script. It only triggers when the script `(2)` is downloaded is executed.
+
+Deferred scripts keep their relative order, just like regular scripts.
+
+So, if we have a long script first, and then a smaller one, then the latter one waits.
+
+```html
+<script async src="https://javascript.info/article/script-async-defer/long.js"></script>
+<script async src="https://javascript.info/article/script-async-defer/small.js"></script>
+```
+
+```smart header="The small script downloads first, runs second"
+Browsers scan the page for scripts and download them in parallel, to improve performance. So in the example above both scripts download in parallel. The `small.js` probably makes it first.
+
+But the specification requres scripts to execute in the document order, so it waits for `long.js` to execute.
+```
+
+```smart header="The `defer` attribute is only for external scripts"
+The `defer` attribute is ignored if the script has no `src`.
+```
+
+
+## async
+
+The `async` attribute means that a script is completely independant:
+
+- The page doesn't wait for async scripts, the contents is processed and displayed.
+- `DOMContentLoaded` and async scripts don't wait each other:
+    - `DOMContentLoaded` may happen both before an async script (if an async script finishes loading after the page is complete)
+    - ...or after an async script (if an async script is short or was in HTTP-cache)
+- Other scripts don't wait for `async` scripts, and `async` scripts don't wait for them.
+
+
+So, if we have several `async` scripts, they may execute in any order. Whatever loads first -- runs first:
+
+```html run height=100
+<p>...content before scripts...</p>
+
+<script>
+  document.addEventListener('DOMContentLoaded', () => alert("DOM ready!"));
+</script>
+
+<script async src="https://javascript.info/article/script-async-defer/long.js"></script>
+<script async src="https://javascript.info/article/script-async-defer/small.js"></script>
+
+<p>...content after scripts...</p>
+```
+
+1. The page content shows up immediately: `async` doesn't block it.
+2. `DOMContentLoaded` may happen both before and after `async`, no guarantees here.
+3. Async scripts don't wait for each other. A smaller script `small.js` goes second, but probably loads before `long.js`, so runs first. That's called a "load-first" order.
+
+Async scripts are great when we integrate an independant third-party script into the page: counters, ads and so on.
+
+```html
+<script async src="https://google-analytics.com/analytics.js"></script>
+```
+
+
+## Dynamic scripts
+
+We can also create a script dynamically using JavaScript:
+
+```js run
+let script = document.createElement('script');
+script.src = "/article/script-async-defer/long.js";
+document.body.append(script); // (*)
+```
+
+The script starts loading as soon as it's appended to the document `(*)`.
+
+**Dynamic scripts behave as "async" by default.**
+
+That is:
+- They don't wait for anything, nothing waits for them.
+- The script that loads first -- runs first ("load-first" order).
+
+We can change the load-first order into the document order by explicitly setting `async` to `false`:
+
+```js run
+let script = document.createElement('script');
+script.src = "/article/script-async-defer/long.js";
+
+*!*
+script.async = false;
+*/!*
+
+document.body.append(script);
+```
+
+For example, here we add two scripts. Without `script.async=false` they would execute in load-first order (the `small.js` probably first). But with that flag the order is "as in the document":
+
+
+```js run
+function loadScript(src) {
+  let script = document.createElement('script');
+  script.src = src;
+  script.async = false;
+  document.body.append(script);
+}
+
+// long.js runs first because of async=false
+loadScript("/article/script-async-defer/long.js");
+loadScript("/article/script-async-defer/small.js");
+```
+
+
+## Summary
+
+Both `async` and `defer` have one common thing: they don't block page rendering. So the user can read page content and get acquanted with the page immediately.
+
+But there are also essential differences between them:
+
+|         | Order | `DOMContentLoaded` |
+|---------|---------|---------|
+| `async` | *Load-first order*. Their document order doesn't matter -- which loads first |  Irrelevant. May load and execute while the document has not yet been fully downloaded. That happens if scripts are small or cached, and the document is long enough. |
+| `defer` | *Document order* (as they go in the document). |  Execute after the document is loaded and parsed (they wait if needed), right before `DOMContentLoaded`. |
+
+```warn header="Page without scripts should be usable"
+Please note that if you're using `defer`, then the page is visible before the script loads and enables all the graphical components.
+
+So, buttons should be disabled by CSS or by other means, to let the user
+
+In practice, `defer` is used for scripts that need DOM and/or their relative execution order is important.
+
+
+So `async` is used for independent scripts, like counters or ads, that don't need to access page content. And their relative execution order does not matter.
diff --git a/2-ui/5-loading/02-script-async-defer/long.js b/2-ui/5-loading/02-script-async-defer/long.js
new file mode 100644
index 000000000..48710f1c6
--- /dev/null
+++ b/2-ui/5-loading/02-script-async-defer/long.js
@@ -0,0 +1,32 @@
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+// ...long js... ...long js... ...long js... ...long js... ...long js... ...long js...
+
+alert("Long script loaded");
diff --git a/2-ui/5-loading/02-script-async-defer/small.js b/2-ui/5-loading/02-script-async-defer/small.js
new file mode 100644
index 000000000..ec743a025
--- /dev/null
+++ b/2-ui/5-loading/02-script-async-defer/small.js
@@ -0,0 +1,3 @@
+// ...small js...
+
+alert("Small script loaded");
diff --git a/2-ui/5-loading/02-script-async-defer/window-onbeforeunload.view/index.html b/2-ui/5-loading/02-script-async-defer/window-onbeforeunload.view/index.html
new file mode 100644
index 000000000..eacfda1f7
--- /dev/null
+++ b/2-ui/5-loading/02-script-async-defer/window-onbeforeunload.view/index.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+</head>
+<body>
+  <script>
+    function setHandler() {
+      window.onbeforeunload = function() {
+        return "There are unsaved changes. Leave now?";
+      };
+    }
+  </script>
+
+  <button onclick="setHandler()">Set window.onbeforeunload</button>
+
+  <a href="http://example.com">Leave for EXAMPLE.COM</a>
+</body>
+</html>
diff --git a/2-ui/3-event-details/11-onload-onerror/1-load-img-callback/solution.md b/2-ui/5-loading/03-onload-onerror/1-load-img-callback/solution.md
similarity index 100%
rename from 2-ui/3-event-details/11-onload-onerror/1-load-img-callback/solution.md
rename to 2-ui/5-loading/03-onload-onerror/1-load-img-callback/solution.md
diff --git a/2-ui/3-event-details/11-onload-onerror/1-load-img-callback/solution.view/index.html b/2-ui/5-loading/03-onload-onerror/1-load-img-callback/solution.view/index.html
similarity index 100%
rename from 2-ui/3-event-details/11-onload-onerror/1-load-img-callback/solution.view/index.html
rename to 2-ui/5-loading/03-onload-onerror/1-load-img-callback/solution.view/index.html
diff --git a/2-ui/3-event-details/11-onload-onerror/1-load-img-callback/source.view/index.html b/2-ui/5-loading/03-onload-onerror/1-load-img-callback/source.view/index.html
similarity index 100%
rename from 2-ui/3-event-details/11-onload-onerror/1-load-img-callback/source.view/index.html
rename to 2-ui/5-loading/03-onload-onerror/1-load-img-callback/source.view/index.html
diff --git a/2-ui/3-event-details/11-onload-onerror/1-load-img-callback/task.md b/2-ui/5-loading/03-onload-onerror/1-load-img-callback/task.md
similarity index 86%
rename from 2-ui/3-event-details/11-onload-onerror/1-load-img-callback/task.md
rename to 2-ui/5-loading/03-onload-onerror/1-load-img-callback/task.md
index bc742ab13..b7583550b 100644
--- a/2-ui/3-event-details/11-onload-onerror/1-load-img-callback/task.md
+++ b/2-ui/5-loading/03-onload-onerror/1-load-img-callback/task.md
@@ -4,7 +4,7 @@ importance: 4
 
 # Load images with a callback
 
-Normally, images are loaded when they are created. So i when we add `<img>` to the page, the user does not see the picture immediately. The browser needs to load it first.
+Normally, images are loaded when they are created. So when we add `<img>` to the page, the user does not see the picture immediately. The browser needs to load it first.
 
 To show an image immediately, we can create it "in advance", like this:
 
diff --git a/2-ui/5-loading/03-onload-onerror/article.md b/2-ui/5-loading/03-onload-onerror/article.md
new file mode 100644
index 000000000..e915dedb6
--- /dev/null
+++ b/2-ui/5-loading/03-onload-onerror/article.md
@@ -0,0 +1,206 @@
+# Resource loading: onload and onerror
+
+The browser allows to track the loading of external resources -- scripts, iframes, pictures and so on.
+
+There are two events for it:
+
+- `onload` -- successful load,
+- `onerror` -- an error occurred.
+
+## Loading a script
+
+Let's say we need to load a third-party script and call a function that resides there.
+
+We can load it dynamically, like this:
+
+```js
+let script = document.createElement('script');
+script.src = "my.js";
+
+document.head.append(script);
+```
+
+...But how to run the function that is declared inside that script? We need to wait until the script loads, and only then we can call it.
+
+```smart
+For our own scripts we could use [JavaScript modules](info:modules) here, but they are not widely adopted by third-party libraries.
+```
+
+### script.onload
+
+The main helper is the `load` event. It triggers after the script was loaded and executed.
+
+For instance:
+
+```js run untrusted
+let script = document.createElement('script');
+
+// can load any script, from any domain
+script.src = "https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.3.0/lodash.js"
+document.head.append(script);
+
+*!*
+script.onload = function() {
+  // the script creates a helper function "_"
+  alert(_); // the function is available
+};
+*/!*
+```
+
+So in `onload` we can use script variables, run functions etc.
+
+...And what if the loading failed? For instance, there's no such script (error 404) or the server or the server is down (unavailable).
+
+### script.onerror
+
+Errors that occur during the loading of the script can be tracked on `error` event.
+
+For instance, let's request a script that doesn't exist:
+
+```js run
+let script = document.createElement('script');
+script.src = "https://example.com/404.js"; // no such script
+document.head.append(script);
+
+*!*
+script.onerror = function() {
+  alert("Error loading " + this.src); // Error loading https://example.com/404.js
+};
+*/!*
+```
+
+Please note that we can't get HTTP error details here. We don't know was it error 404 or 500 or something else. Just that the loading failed.
+
+```warn
+Events `onload`/`onerror` track only the loading itself.
+
+Errors during script processing and execution are out of the scope of these events. To track script errors, one can use `window.onerror` global handler.
+```
+
+## Other resources
+
+The `load` and `error` events also work for other resources, basically for any resource that has an external `src`.
+
+For example:
+
+```js run
+let img = document.createElement('img');
+img.src = "https://js.cx/clipart/train.gif"; // (*)
+
+img.onload = function() {
+  alert(`Image loaded, size ${img.width}x${img.height}`);
+};
+
+img.onerror = function() {
+  alert("Error occured while loading image");
+};
+```
+
+There are some notes though:
+
+- Most resources start loading when they are added to the document. But `<img>` is an exception. It starts loading when it gets an src `(*)`.
+- For `<iframe>`, the `iframe.onload` event triggers when the iframe loading finished, both for successful load and in case of an error.
+
+That's for historical reasons.
+
+## Crossorigin policy
+
+There's a rule: scripts from one site can't access contents of the other site. So, e.g. a script at `https://facebook.com` can't read the user's mailbox at `https://gmail.com`.
+
+Or, to be more precise, one origin (domain/port/protocol triplet) can't access the content from another one. So even if we have a subdomain, or just another port, these are different origins, no access to each other.
+
+This rule also affects resources from other domains.
+
+If we're using a script from another domain, and there's an error in it, we can't get error details.
+
+For example, let's take a script with a single (bad) function call:
+```js
+// 📁 error.js
+noSuchFunction();
+```
+
+Now load it from our domain:
+
+```html run height=0
+<script>
+window.onerror = function(message, url, line, col, errorObj) {
+  alert(`${message}\n${url}, ${line}:${col}`);
+};
+</script>
+<script src="/https/patch-diff.githubusercontent.com/article/onload-onerror/crossorigin/error.js"></script>
+```
+
+We can see a good error report, like this:
+
+```
+Uncaught ReferenceError: noSuchFunction is not defined
+https://javascript.info/article/onload-onerror/crossorigin/error.js, 1:1
+```
+
+Now let's load the same script from another domain:
+
+```html run height=0
+<script>
+window.onerror = function(message, url, line, col, errorObj) {
+  alert(`${message}\n${url}, ${line}:${col}`);
+};
+</script>
+<script src="https://cors.javascript.info/article/onload-onerror/crossorigin/error.js"></script>
+```
+
+The report is different, like this:
+
+```
+Script error.
+, 0:0
+```
+
+Details may vary depeding on the browser, but the idea is same: any information about the internals of a script is hidden. Exactly because it's from another domain.
+
+Why do we need the details?
+
+There are many services (and we can build our own) that listen to `window.onerror`, save errors at the server and provide an interface to access and analyze them. That's great, as we can see real errors, triggered by our users. But we can't see any error information for scripts from other domains.
+
+Similar cross-origin policy (CORS) is enforced for other types of resources as well.
+
+**To allow cross-origin access, we need `crossorigin` attribute, plus the remote server must provide special headers.**
+
+There are three levels of cross-origin access:
+
+1. **No `crossorigin` attribute** -- access prohibited.
+2. **`crossorigin="anonymous"`** -- access allowed if the server responds with the header `Access-Control-Allow-Origin` with `*` or our origin. Browser does not send authorization information and cookies to remote server.
+3. **`crossorigin="use-credentials"`** -- access allowed if the server sends back the header `Access-Control-Allow-Origin` with our origin and `Access-Control-Allow-Credentials: true`.  Browser sends authorization information and cookies to remote server.
+
+```smart
+You can read more about cross-origin access in the chapter <info:fetch-crossorigin>. It describes `fetch` method for network requests, but the policy is exactly the same.
+
+Such thing as "cookies" is out of our current scope, but you can read about them in the chapter <info:cookie>.
+```
+
+In our case, we didn't have any crossorigin attribute. So the cross-origin access was prohibited. Let's add it.
+
+We can choose between `"anonymous"` (no cookies sent, one server-side header needed) and `"use-credentials"` (sends cookies too, two server-side headers needed).
+
+If we don't care about cookies, then `"anonymous"` is a way to go:
+
+```html run height=0
+<script>
+window.onerror = function(message, url, line, col, errorObj) {
+  alert(`${message}\n${url}, ${line}:${col}`);
+};
+</script>
+<script *!*crossorigin="anonymous"*/!* src="https://cors.javascript.info/article/onload-onerror/crossorigin/error.js"></script>
+```
+
+Now, assuming that the server provides `Access-Control-Allow-Origin` header, everything's fine. We have the full error report.
+
+## Summary
+
+Images `<img>`, external styles, scripts and other resources provide `load` and `error` events to track their loading:
+
+- `load` triggers on a successful load,
+- `error` triggers on a failed load.
+
+The only exception is `<iframe>`: for historical reasons it always triggers `load`, for any load completion, even if the page is not found.
+
+The `readystatechange` event also works for resources, but is rarely used, because `load/error` events are simpler.
diff --git a/2-ui/5-loading/03-onload-onerror/crossorigin.view/error.js b/2-ui/5-loading/03-onload-onerror/crossorigin.view/error.js
new file mode 100644
index 000000000..a7ac6ef5a
--- /dev/null
+++ b/2-ui/5-loading/03-onload-onerror/crossorigin.view/error.js
@@ -0,0 +1 @@
+noSuchFunction();
diff --git a/2-ui/5-loading/index.md b/2-ui/5-loading/index.md
new file mode 100644
index 000000000..9e01193d3
--- /dev/null
+++ b/2-ui/5-loading/index.md
@@ -0,0 +1,2 @@
+
+# Document and resource loading
diff --git a/3-animation/1-bezier-curve/bezier-car.png b/3-animation/1-bezier-curve/bezier-car.png
deleted file mode 100644
index 5df005c3c..000000000
Binary files a/3-animation/1-bezier-curve/bezier-car.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier-car@2x.png b/3-animation/1-bezier-curve/bezier-car@2x.png
deleted file mode 100644
index 990ecac3e..000000000
Binary files a/3-animation/1-bezier-curve/bezier-car@2x.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier-letter.png b/3-animation/1-bezier-curve/bezier-letter.png
deleted file mode 100644
index 636c2abec..000000000
Binary files a/3-animation/1-bezier-curve/bezier-letter.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier-letter@2x.png b/3-animation/1-bezier-curve/bezier-letter@2x.png
deleted file mode 100644
index 86e8f80ef..000000000
Binary files a/3-animation/1-bezier-curve/bezier-letter@2x.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier-vase.png b/3-animation/1-bezier-curve/bezier-vase.png
deleted file mode 100644
index 1fdc08f76..000000000
Binary files a/3-animation/1-bezier-curve/bezier-vase.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier-vase@2x.png b/3-animation/1-bezier-curve/bezier-vase@2x.png
deleted file mode 100644
index e60ced0de..000000000
Binary files a/3-animation/1-bezier-curve/bezier-vase@2x.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier2.png b/3-animation/1-bezier-curve/bezier2.png
deleted file mode 100644
index cbad0a367..000000000
Binary files a/3-animation/1-bezier-curve/bezier2.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier2@2x.png b/3-animation/1-bezier-curve/bezier2@2x.png
deleted file mode 100644
index 6dbf1bfd8..000000000
Binary files a/3-animation/1-bezier-curve/bezier2@2x.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier3-draw1.png b/3-animation/1-bezier-curve/bezier3-draw1.png
deleted file mode 100644
index 177af2475..000000000
Binary files a/3-animation/1-bezier-curve/bezier3-draw1.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier3-draw1@2x.png b/3-animation/1-bezier-curve/bezier3-draw1@2x.png
deleted file mode 100644
index badd242df..000000000
Binary files a/3-animation/1-bezier-curve/bezier3-draw1@2x.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier3-draw2.png b/3-animation/1-bezier-curve/bezier3-draw2.png
deleted file mode 100644
index f27ebcd76..000000000
Binary files a/3-animation/1-bezier-curve/bezier3-draw2.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier3-draw2@2x.png b/3-animation/1-bezier-curve/bezier3-draw2@2x.png
deleted file mode 100644
index 129eb36e2..000000000
Binary files a/3-animation/1-bezier-curve/bezier3-draw2@2x.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier3-e.png b/3-animation/1-bezier-curve/bezier3-e.png
deleted file mode 100644
index f5b9e6284..000000000
Binary files a/3-animation/1-bezier-curve/bezier3-e.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier3-e@2x.png b/3-animation/1-bezier-curve/bezier3-e@2x.png
deleted file mode 100644
index bc4da5f76..000000000
Binary files a/3-animation/1-bezier-curve/bezier3-e@2x.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier3.png b/3-animation/1-bezier-curve/bezier3.png
deleted file mode 100644
index 890e6c270..000000000
Binary files a/3-animation/1-bezier-curve/bezier3.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier3@2x.png b/3-animation/1-bezier-curve/bezier3@2x.png
deleted file mode 100644
index 343d48c95..000000000
Binary files a/3-animation/1-bezier-curve/bezier3@2x.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier4-e.png b/3-animation/1-bezier-curve/bezier4-e.png
deleted file mode 100644
index 1761ce21e..000000000
Binary files a/3-animation/1-bezier-curve/bezier4-e.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier4-e@2x.png b/3-animation/1-bezier-curve/bezier4-e@2x.png
deleted file mode 100644
index b21b88698..000000000
Binary files a/3-animation/1-bezier-curve/bezier4-e@2x.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier4.png b/3-animation/1-bezier-curve/bezier4.png
deleted file mode 100644
index 9176f973f..000000000
Binary files a/3-animation/1-bezier-curve/bezier4.png and /dev/null differ
diff --git a/3-animation/1-bezier-curve/bezier4@2x.png b/3-animation/1-bezier-curve/bezier4@2x.png
deleted file mode 100644
index f4e8d790b..000000000
Binary files a/3-animation/1-bezier-curve/bezier4@2x.png and /dev/null differ
diff --git a/3-animation/2-css-animations/2-animate-logo-bezier-css/bezier-up.png b/3-animation/2-css-animations/2-animate-logo-bezier-css/bezier-up.png
deleted file mode 100644
index 91e2bfe58..000000000
Binary files a/3-animation/2-css-animations/2-animate-logo-bezier-css/bezier-up.png and /dev/null differ
diff --git a/3-animation/2-css-animations/2-animate-logo-bezier-css/bezier-up@2x.png b/3-animation/2-css-animations/2-animate-logo-bezier-css/bezier-up@2x.png
deleted file mode 100644
index 31384e53d..000000000
Binary files a/3-animation/2-css-animations/2-animate-logo-bezier-css/bezier-up@2x.png and /dev/null differ
diff --git a/3-animation/2-css-animations/bezier-linear.png b/3-animation/2-css-animations/bezier-linear.png
deleted file mode 100644
index 795e4cdf4..000000000
Binary files a/3-animation/2-css-animations/bezier-linear.png and /dev/null differ
diff --git a/3-animation/2-css-animations/bezier-linear@2x.png b/3-animation/2-css-animations/bezier-linear@2x.png
deleted file mode 100644
index 95ec3cf91..000000000
Binary files a/3-animation/2-css-animations/bezier-linear@2x.png and /dev/null differ
diff --git a/3-animation/2-css-animations/bezier-train-over.png b/3-animation/2-css-animations/bezier-train-over.png
deleted file mode 100644
index bd4822907..000000000
Binary files a/3-animation/2-css-animations/bezier-train-over.png and /dev/null differ
diff --git a/3-animation/2-css-animations/bezier-train-over@2x.png b/3-animation/2-css-animations/bezier-train-over@2x.png
deleted file mode 100644
index 8dad7cc34..000000000
Binary files a/3-animation/2-css-animations/bezier-train-over@2x.png and /dev/null differ
diff --git a/3-animation/2-css-animations/ease-in-out.png b/3-animation/2-css-animations/ease-in-out.png
deleted file mode 100644
index 50ed8a7bb..000000000
Binary files a/3-animation/2-css-animations/ease-in-out.png and /dev/null differ
diff --git a/3-animation/2-css-animations/ease-in-out@2x.png b/3-animation/2-css-animations/ease-in-out@2x.png
deleted file mode 100644
index 067ad9bae..000000000
Binary files a/3-animation/2-css-animations/ease-in-out@2x.png and /dev/null differ
diff --git a/3-animation/2-css-animations/ease-in.png b/3-animation/2-css-animations/ease-in.png
deleted file mode 100644
index e00c52c45..000000000
Binary files a/3-animation/2-css-animations/ease-in.png and /dev/null differ
diff --git a/3-animation/2-css-animations/ease-in@2x.png b/3-animation/2-css-animations/ease-in@2x.png
deleted file mode 100644
index 14207250c..000000000
Binary files a/3-animation/2-css-animations/ease-in@2x.png and /dev/null differ
diff --git a/3-animation/2-css-animations/ease-out.png b/3-animation/2-css-animations/ease-out.png
deleted file mode 100644
index b95ce5505..000000000
Binary files a/3-animation/2-css-animations/ease-out.png and /dev/null differ
diff --git a/3-animation/2-css-animations/ease-out@2x.png b/3-animation/2-css-animations/ease-out@2x.png
deleted file mode 100644
index df4cca89d..000000000
Binary files a/3-animation/2-css-animations/ease-out@2x.png and /dev/null differ
diff --git a/3-animation/2-css-animations/ease.png b/3-animation/2-css-animations/ease.png
deleted file mode 100644
index 2d4d91cdd..000000000
Binary files a/3-animation/2-css-animations/ease.png and /dev/null differ
diff --git a/3-animation/2-css-animations/ease@2x.png b/3-animation/2-css-animations/ease@2x.png
deleted file mode 100644
index 49eeb9606..000000000
Binary files a/3-animation/2-css-animations/ease@2x.png and /dev/null differ
diff --git a/3-animation/2-css-animations/train-curve.png b/3-animation/2-css-animations/train-curve.png
deleted file mode 100644
index 213ed84a6..000000000
Binary files a/3-animation/2-css-animations/train-curve.png and /dev/null differ
diff --git a/3-animation/2-css-animations/train-curve@2x.png b/3-animation/2-css-animations/train-curve@2x.png
deleted file mode 100644
index 4d8d698da..000000000
Binary files a/3-animation/2-css-animations/train-curve@2x.png and /dev/null differ
diff --git a/3-animation/3-js-animation/back.png b/3-animation/3-js-animation/back.png
deleted file mode 100644
index c63bc9d95..000000000
Binary files a/3-animation/3-js-animation/back.png and /dev/null differ
diff --git a/3-animation/3-js-animation/back@2x.png b/3-animation/3-js-animation/back@2x.png
deleted file mode 100644
index 794f16235..000000000
Binary files a/3-animation/3-js-animation/back@2x.png and /dev/null differ
diff --git a/3-animation/3-js-animation/bezier-linear.png b/3-animation/3-js-animation/bezier-linear.png
deleted file mode 100644
index 795e4cdf4..000000000
Binary files a/3-animation/3-js-animation/bezier-linear.png and /dev/null differ
diff --git a/3-animation/3-js-animation/bezier-linear@2x.png b/3-animation/3-js-animation/bezier-linear@2x.png
deleted file mode 100644
index 95ec3cf91..000000000
Binary files a/3-animation/3-js-animation/bezier-linear@2x.png and /dev/null differ
diff --git a/3-animation/3-js-animation/bounce-inout.png b/3-animation/3-js-animation/bounce-inout.png
deleted file mode 100644
index af1e90d76..000000000
Binary files a/3-animation/3-js-animation/bounce-inout.png and /dev/null differ
diff --git a/3-animation/3-js-animation/bounce-inout@2x.png b/3-animation/3-js-animation/bounce-inout@2x.png
deleted file mode 100644
index 1c558f469..000000000
Binary files a/3-animation/3-js-animation/bounce-inout@2x.png and /dev/null differ
diff --git a/3-animation/3-js-animation/circ-ease.png b/3-animation/3-js-animation/circ-ease.png
deleted file mode 100644
index 657942f73..000000000
Binary files a/3-animation/3-js-animation/circ-ease.png and /dev/null differ
diff --git a/3-animation/3-js-animation/circ-ease@2x.png b/3-animation/3-js-animation/circ-ease@2x.png
deleted file mode 100644
index 9f68a73f2..000000000
Binary files a/3-animation/3-js-animation/circ-ease@2x.png and /dev/null differ
diff --git a/3-animation/3-js-animation/circ.png b/3-animation/3-js-animation/circ.png
deleted file mode 100644
index cdb43f798..000000000
Binary files a/3-animation/3-js-animation/circ.png and /dev/null differ
diff --git a/3-animation/3-js-animation/circ@2x.png b/3-animation/3-js-animation/circ@2x.png
deleted file mode 100644
index 7d1c7ced9..000000000
Binary files a/3-animation/3-js-animation/circ@2x.png and /dev/null differ
diff --git a/3-animation/3-js-animation/elastic.png b/3-animation/3-js-animation/elastic.png
deleted file mode 100644
index f18ffbdca..000000000
Binary files a/3-animation/3-js-animation/elastic.png and /dev/null differ
diff --git a/3-animation/3-js-animation/elastic@2x.png b/3-animation/3-js-animation/elastic@2x.png
deleted file mode 100644
index 2dbd6d3cf..000000000
Binary files a/3-animation/3-js-animation/elastic@2x.png and /dev/null differ
diff --git a/3-animation/3-js-animation/linear.png b/3-animation/3-js-animation/linear.png
deleted file mode 100644
index 9d29ec1bd..000000000
Binary files a/3-animation/3-js-animation/linear.png and /dev/null differ
diff --git a/3-animation/3-js-animation/linear@2x.png b/3-animation/3-js-animation/linear@2x.png
deleted file mode 100644
index e10b7fef8..000000000
Binary files a/3-animation/3-js-animation/linear@2x.png and /dev/null differ
diff --git a/3-animation/3-js-animation/quad.png b/3-animation/3-js-animation/quad.png
deleted file mode 100644
index 670715a7f..000000000
Binary files a/3-animation/3-js-animation/quad.png and /dev/null differ
diff --git a/3-animation/3-js-animation/quad@2x.png b/3-animation/3-js-animation/quad@2x.png
deleted file mode 100644
index 9a3ca207b..000000000
Binary files a/3-animation/3-js-animation/quad@2x.png and /dev/null differ
diff --git a/3-animation/3-js-animation/quint.png b/3-animation/3-js-animation/quint.png
deleted file mode 100644
index 35c06319a..000000000
Binary files a/3-animation/3-js-animation/quint.png and /dev/null differ
diff --git a/3-animation/3-js-animation/quint@2x.png b/3-animation/3-js-animation/quint@2x.png
deleted file mode 100644
index d3477022a..000000000
Binary files a/3-animation/3-js-animation/quint@2x.png and /dev/null differ
diff --git a/4-frames-and-windows/01-popup-windows/article.md b/3-frames-and-windows/01-popup-windows/article.md
similarity index 95%
rename from 4-frames-and-windows/01-popup-windows/article.md
rename to 3-frames-and-windows/01-popup-windows/article.md
index 21ddfb118..57c0c50d3 100644
--- a/4-frames-and-windows/01-popup-windows/article.md
+++ b/3-frames-and-windows/01-popup-windows/article.md
@@ -4,7 +4,7 @@ A popup window is one of the oldest methods to show additional document to user.
 
 Basically, you just run:
 ```js
-window.open('http://javascript.info/')
+window.open('https://javascript.info/')
 ```
 
 ... And it will open a new window with given URL. Most modern browsers are configured to open new tabs instead of separate windows.
@@ -17,7 +17,20 @@ In the past evil sites abused popups a lot. A bad page could open tons of popup
 
 **Most browsers block popups if they are called outside of user-triggered event handlers like `onclick`.**
 
-If you think about it, that's a bit tricky. If the code is directly in an `onclick` handler, then that's easy. But what is the popup opens in `setTimeout`?
+For example:
+```js
+// popup blocked
+window.open('https://javascript.info');
+
+// popup allowed
+button.onclick = () => {
+  window.open('https://javascript.info');
+};
+```
+
+This way users are somewhat protected from unwanted popups, but the functionality is not disabled totally.
+
+What if the popup opens from `onclick`, but after `setTimeout`? That's a bit tricky.
 
 Try this code:
 
@@ -28,7 +41,7 @@ setTimeout(() => window.open('http://google.com'), 3000);
 
 The popup opens in Chrome, but gets blocked in Firefox.
 
-...And this works in Firefox too:
+...If we decrease the delay, the popup works in Firefox too:
 
 ```js run
 // open after 1 seconds
diff --git a/4-frames-and-windows/03-cross-window-communication/article.md b/3-frames-and-windows/03-cross-window-communication/article.md
similarity index 95%
rename from 4-frames-and-windows/03-cross-window-communication/article.md
rename to 3-frames-and-windows/03-cross-window-communication/article.md
index a4193a62d..53cb3cd6e 100644
--- a/4-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -24,9 +24,9 @@ These ones do not:
 The "Same Origin" policy states that:
 
 - if we have a reference to another window, e.g. a popup created by `window.open` or a window inside `<iframe>`, and that window comes from the same origin, then we have full access to that window.
-- otherwise, if it comes from another origin, then we can't access the content of that window: variables, document, anything. The only exception is `location`: we can change it (thus redirecting the user). But we can't not *read* location (so we can't see where the user is now, no information leak).
+- otherwise, if it comes from another origin, then we can't access the content of that window: variables, document, anything. The only exception is `location`: we can change it (thus redirecting the user). But we cannot *read* location (so we can't see where the user is now, no information leak).
 
-Now let's see how some examples. First, about pages that come from the same origin, and thus there are no limitations. And afterwards we'll cover cross-window messaging that allows to work around the "Same Origin" policy.
+Now let's see some examples. First, we'll look at pages that come from the same origin and do not conflict with the "Same Origin" policy, and afterwards we'll cover cross-window messaging that allows to work around the "Same Origin" policy.
 
 
 ````warn header="Subdomains may be same-origin"
@@ -134,7 +134,7 @@ Here, look:
 </script>
 ```
 
-That's actually a well-known pitfall for novice developers. We shouldn't work with the document immediately, because that's the *wrong document*. If we set any event handlers on it, they will be ignored.
+That's actually a well-known pitfall for developers. We shouldn't work with the document immediately, because that's the *wrong document*. If we set any event handlers on it, they will be ignored.
 
 ...But the `onload` event triggers when the whole iframe with all resources is loaded. What if we want to act sooner, on `DOMContentLoaded` of the embedded document?
 
@@ -246,7 +246,7 @@ The purpose of the `"sandbox"` attribute is only to *add more* restrictions. It
 
 The `postMessage` interface allows windows to talk to each other no matter which origin they are from.
 
-So, it's a way around the "Same Origin" policy. It allows a window from `john-smith.com` to talk to `gmail.com` and exchange information, but only if they both agree and call corresponding Javascript functions. That makes it safe for users.
+So, it's a way around the "Same Origin" policy. It allows a window from `john-smith.com` to talk to `gmail.com` and exchange information, but only if they both agree and call corresponding JavaScript functions. That makes it safe for users.
 
 The interface has two parts.
 
diff --git a/4-frames-and-windows/03-cross-window-communication/postmessage.view/iframe.html b/3-frames-and-windows/03-cross-window-communication/postmessage.view/iframe.html
similarity index 100%
rename from 4-frames-and-windows/03-cross-window-communication/postmessage.view/iframe.html
rename to 3-frames-and-windows/03-cross-window-communication/postmessage.view/iframe.html
diff --git a/4-frames-and-windows/03-cross-window-communication/postmessage.view/index.html b/3-frames-and-windows/03-cross-window-communication/postmessage.view/index.html
similarity index 100%
rename from 4-frames-and-windows/03-cross-window-communication/postmessage.view/index.html
rename to 3-frames-and-windows/03-cross-window-communication/postmessage.view/index.html
diff --git a/4-frames-and-windows/03-cross-window-communication/sandbox.view/index.html b/3-frames-and-windows/03-cross-window-communication/sandbox.view/index.html
similarity index 100%
rename from 4-frames-and-windows/03-cross-window-communication/sandbox.view/index.html
rename to 3-frames-and-windows/03-cross-window-communication/sandbox.view/index.html
diff --git a/4-frames-and-windows/03-cross-window-communication/sandbox.view/sandboxed.html b/3-frames-and-windows/03-cross-window-communication/sandbox.view/sandboxed.html
similarity index 100%
rename from 4-frames-and-windows/03-cross-window-communication/sandbox.view/sandboxed.html
rename to 3-frames-and-windows/03-cross-window-communication/sandbox.view/sandboxed.html
diff --git a/4-frames-and-windows/06-clickjacking/article.md b/3-frames-and-windows/06-clickjacking/article.md
similarity index 76%
rename from 4-frames-and-windows/06-clickjacking/article.md
rename to 3-frames-and-windows/06-clickjacking/article.md
index de8dcfa08..9752835e5 100644
--- a/4-frames-and-windows/06-clickjacking/article.md
+++ b/3-frames-and-windows/06-clickjacking/article.md
@@ -2,7 +2,7 @@
 
 The "clickjacking" attack allows an evil page to click on a "victim site" *on behalf of the visitor*.
 
-Many sites were hacked this way, including Twitter, Facebook, Paypal and other sites. They are all fixed, of course.
+Many sites were hacked this way, including Twitter, Facebook, Paypal and other sites. They have all been fixed, of course.
 
 ## The idea
 
@@ -189,6 +189,42 @@ The demo:
 
 [codetabs src="protector"]
 
+## Samesite cookie attribute
+
+The `samesite` cookie attribute can also prevent clickjacking attacks. The purpose of the attribute is to prevent cookies from being sent to a website when the user doesn't intend to visit the website. It is designed to prevent cross-site request forgery attacks, but also helps with clickjacking because a hijacked click usually results in an unintended request to a different site. When a cookie has the `samesite` attribute, whether the value is `strict` or `lax`, cookies are not sent to a website when it is loaded inside an iframe. 
+
+The `samesite` attribute can be set using HTTP response headers or JavaScript. Via HTTP, it looks like: 
+
+`Set-Cookie: demoCookie=demoValue; samesite=lax`
+
+or
+
+`Set-Cookie: demoCookie=demoValue; samesite=strict`
+
+In JavaScript, it is: 
+
+```html
+document.cookie = "demoCookie=demoValue; SameSite=Lax";
+document.cookie = "demoCookie=demoValue; SameSite=Strict";
+```
+
+When the value is `lax`, these types of requests are blocked: 
+- Form POST submit (&lt;form method="POST" action="..."&gt;)
+- iframe (&lt;iframe src="..."&gt;&lt;/iframe&gt;)
+- AJAX ($.get("..."))
+- Image (&lt;img src="..."&gt;)
+- Script (&lt;script src="..."&gt;&lt;/script&gt;)
+- Stylesheet (&lt;link rel="stylesheet" type="text/css" href="..."&gt;)
+
+When the value is `strict`, these types of requests are also blocked, in addition to those under `lax`: 
+- Clicking a link (&lt;a href="..."&gt;&lt;/a&gt;)
+- Prerender (&lt;link rel="prerender" href=".."/&gt;)
+- Form GET submit (&lt;form method="GET" action="..."&gt;)
+
+In this case, we are concerned with iframe requests. A clickjacking attempt would fail because the user is not considered logged into, for example, Facebook, so they can't "Like" anything through the iframe. 
+
+The `samesite` attribute will not have an effect when cookies are not used. This may allow websites to easily show public, unauthenticated pages in iframes on unaffiliated websites. However, this may also allow clickjacking attacks to work in a few limited cases. An anonymous polling website that prevents duplicate voting by checking IP addresses, for example, would still be vulnerable to clickjacking because it does not authenticate users using cookies. 
+
 ## Summary
 
 Clickjacking is a way to "trick" users into clicking on a malicious site without even knowing what's happening. That's dangerous if there are important click-activated actions.
diff --git a/4-frames-and-windows/06-clickjacking/clickjacking-visible.view/facebook.html b/3-frames-and-windows/06-clickjacking/clickjacking-visible.view/facebook.html
similarity index 100%
rename from 4-frames-and-windows/06-clickjacking/clickjacking-visible.view/facebook.html
rename to 3-frames-and-windows/06-clickjacking/clickjacking-visible.view/facebook.html
diff --git a/4-frames-and-windows/06-clickjacking/clickjacking-visible.view/index.html b/3-frames-and-windows/06-clickjacking/clickjacking-visible.view/index.html
similarity index 100%
rename from 4-frames-and-windows/06-clickjacking/clickjacking-visible.view/index.html
rename to 3-frames-and-windows/06-clickjacking/clickjacking-visible.view/index.html
diff --git a/4-frames-and-windows/06-clickjacking/clickjacking.view/facebook.html b/3-frames-and-windows/06-clickjacking/clickjacking.view/facebook.html
similarity index 100%
rename from 4-frames-and-windows/06-clickjacking/clickjacking.view/facebook.html
rename to 3-frames-and-windows/06-clickjacking/clickjacking.view/facebook.html
diff --git a/4-frames-and-windows/06-clickjacking/clickjacking.view/index.html b/3-frames-and-windows/06-clickjacking/clickjacking.view/index.html
similarity index 100%
rename from 4-frames-and-windows/06-clickjacking/clickjacking.view/index.html
rename to 3-frames-and-windows/06-clickjacking/clickjacking.view/index.html
diff --git a/4-frames-and-windows/06-clickjacking/protector.view/iframe.html b/3-frames-and-windows/06-clickjacking/protector.view/iframe.html
similarity index 100%
rename from 4-frames-and-windows/06-clickjacking/protector.view/iframe.html
rename to 3-frames-and-windows/06-clickjacking/protector.view/iframe.html
diff --git a/4-frames-and-windows/06-clickjacking/protector.view/index.html b/3-frames-and-windows/06-clickjacking/protector.view/index.html
similarity index 100%
rename from 4-frames-and-windows/06-clickjacking/protector.view/index.html
rename to 3-frames-and-windows/06-clickjacking/protector.view/index.html
diff --git a/4-frames-and-windows/06-clickjacking/top-location.view/iframe.html b/3-frames-and-windows/06-clickjacking/top-location.view/iframe.html
similarity index 100%
rename from 4-frames-and-windows/06-clickjacking/top-location.view/iframe.html
rename to 3-frames-and-windows/06-clickjacking/top-location.view/iframe.html
diff --git a/4-frames-and-windows/06-clickjacking/top-location.view/index.html b/3-frames-and-windows/06-clickjacking/top-location.view/index.html
similarity index 100%
rename from 4-frames-and-windows/06-clickjacking/top-location.view/index.html
rename to 3-frames-and-windows/06-clickjacking/top-location.view/index.html
diff --git a/4-frames-and-windows/index.md b/3-frames-and-windows/index.md
similarity index 100%
rename from 4-frames-and-windows/index.md
rename to 3-frames-and-windows/index.md
diff --git a/4-binary/01-arraybuffer-binary-arrays/01-concat/_js.view/solution.js b/4-binary/01-arraybuffer-binary-arrays/01-concat/_js.view/solution.js
new file mode 100644
index 000000000..2f51384ef
--- /dev/null
+++ b/4-binary/01-arraybuffer-binary-arrays/01-concat/_js.view/solution.js
@@ -0,0 +1,18 @@
+function concat(arrays) {
+  // sum of individual array lengths
+  let totalLength = arrays.reduce((acc, value) => acc + value.length, 0);
+
+  if (!arrays.length) return null;
+
+  let result = new Uint8Array(totalLength);
+
+  // for each array - copy it over result
+  // next array is copied right after the previous one
+  let length = 0;
+  for(let array of arrays) {
+    result.set(array, length);
+    length += array.length;
+  }
+
+  return result;
+}
diff --git a/4-binary/01-arraybuffer-binary-arrays/01-concat/_js.view/source.js b/4-binary/01-arraybuffer-binary-arrays/01-concat/_js.view/source.js
new file mode 100644
index 000000000..e88b1a537
--- /dev/null
+++ b/4-binary/01-arraybuffer-binary-arrays/01-concat/_js.view/source.js
@@ -0,0 +1,13 @@
+function concat(arrays) {
+  // ...your code...
+}
+
+let chunks = [
+  new Uint8Array([0, 1, 2]),
+  new Uint8Array([3, 4, 5]),
+  new Uint8Array([6, 7, 8])
+];
+
+console.log(Array.from(concat(chunks))); // 0, 1, 2, 3, 4, 5, 6, 7, 8
+
+console.log(concat(chunks).constructor.name); // Uint8Array
diff --git a/4-binary/01-arraybuffer-binary-arrays/01-concat/_js.view/test.js b/4-binary/01-arraybuffer-binary-arrays/01-concat/_js.view/test.js
new file mode 100644
index 000000000..bcb19daef
--- /dev/null
+++ b/4-binary/01-arraybuffer-binary-arrays/01-concat/_js.view/test.js
@@ -0,0 +1,31 @@
+describe("concat", function() {
+  let chunks = [
+    new Uint8Array([0, 1, 2]),
+    new Uint8Array([3, 4, 5]),
+    new Uint8Array([6, 7, 8])
+  ];
+
+  it("result has the same array type", function() {
+
+    let result = concat(chunks);
+
+    assert.equal(result.constructor, Uint8Array);
+  });
+
+  it("concatenates arrays", function() {
+
+    let result = concat(chunks);
+
+    assert.deepEqual(result, new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8]));
+
+  });
+
+  it("returns empty array on empty input", function() {
+
+    let result = concat([]);
+
+    assert.equal(result.length, 0);
+
+  });
+
+});
diff --git a/6-async/02-promise-basics/03-animate-circle-promise/solution.md b/4-binary/01-arraybuffer-binary-arrays/01-concat/solution.md
similarity index 100%
rename from 6-async/02-promise-basics/03-animate-circle-promise/solution.md
rename to 4-binary/01-arraybuffer-binary-arrays/01-concat/solution.md
diff --git a/4-binary/01-arraybuffer-binary-arrays/01-concat/task.md b/4-binary/01-arraybuffer-binary-arrays/01-concat/task.md
new file mode 100644
index 000000000..6710104b2
--- /dev/null
+++ b/4-binary/01-arraybuffer-binary-arrays/01-concat/task.md
@@ -0,0 +1,4 @@
+
+# Concatenate typed arrays
+
+Given an array of `Uint8Array`, write a function `concat(arrays)` that returns a concatenation of them into a single array.
diff --git a/4-binary/01-arraybuffer-binary-arrays/8bit-integer-256.png b/4-binary/01-arraybuffer-binary-arrays/8bit-integer-256.png
new file mode 100644
index 000000000..3c9bebde5
Binary files /dev/null and b/4-binary/01-arraybuffer-binary-arrays/8bit-integer-256.png differ
diff --git a/4-binary/01-arraybuffer-binary-arrays/8bit-integer-256@2x.png b/4-binary/01-arraybuffer-binary-arrays/8bit-integer-256@2x.png
new file mode 100644
index 000000000..0a6e4a246
Binary files /dev/null and b/4-binary/01-arraybuffer-binary-arrays/8bit-integer-256@2x.png differ
diff --git a/4-binary/01-arraybuffer-binary-arrays/8bit-integer-257.png b/4-binary/01-arraybuffer-binary-arrays/8bit-integer-257.png
new file mode 100644
index 000000000..7be333e03
Binary files /dev/null and b/4-binary/01-arraybuffer-binary-arrays/8bit-integer-257.png differ
diff --git a/4-binary/01-arraybuffer-binary-arrays/8bit-integer-257@2x.png b/4-binary/01-arraybuffer-binary-arrays/8bit-integer-257@2x.png
new file mode 100644
index 000000000..a0b02dbb2
Binary files /dev/null and b/4-binary/01-arraybuffer-binary-arrays/8bit-integer-257@2x.png differ
diff --git a/4-binary/01-arraybuffer-binary-arrays/arraybuffer-view-buffersource.png b/4-binary/01-arraybuffer-binary-arrays/arraybuffer-view-buffersource.png
new file mode 100644
index 000000000..66a23c251
Binary files /dev/null and b/4-binary/01-arraybuffer-binary-arrays/arraybuffer-view-buffersource.png differ
diff --git a/4-binary/01-arraybuffer-binary-arrays/arraybuffer-view-buffersource@2x.png b/4-binary/01-arraybuffer-binary-arrays/arraybuffer-view-buffersource@2x.png
new file mode 100644
index 000000000..dfdd3d884
Binary files /dev/null and b/4-binary/01-arraybuffer-binary-arrays/arraybuffer-view-buffersource@2x.png differ
diff --git a/4-binary/01-arraybuffer-binary-arrays/arraybuffer-views.png b/4-binary/01-arraybuffer-binary-arrays/arraybuffer-views.png
new file mode 100644
index 000000000..7c1f5bbba
Binary files /dev/null and b/4-binary/01-arraybuffer-binary-arrays/arraybuffer-views.png differ
diff --git a/4-binary/01-arraybuffer-binary-arrays/arraybuffer-views@2x.png b/4-binary/01-arraybuffer-binary-arrays/arraybuffer-views@2x.png
new file mode 100644
index 000000000..ebaef188c
Binary files /dev/null and b/4-binary/01-arraybuffer-binary-arrays/arraybuffer-views@2x.png differ
diff --git a/4-binary/01-arraybuffer-binary-arrays/article.md b/4-binary/01-arraybuffer-binary-arrays/article.md
new file mode 100644
index 000000000..d0bb488db
--- /dev/null
+++ b/4-binary/01-arraybuffer-binary-arrays/article.md
@@ -0,0 +1,269 @@
+# ArrayBuffer, binary arrays
+
+In web-development we meet binary data mostly while dealing with files (create, upload, download). Another typical use case is image processing.
+
+That's all possible in JavaScript, and binary operations are high-performant.
+
+Although, there's a bit of confusion, because there are many classes. To name a few:
+- `ArrayBuffer`, `Uint8Array`, `DataView`, `Blob`, `File`, etc.
+
+Binary data in JavaScript is implemented in a non-standard way, compared to other languages. But when we sort things out, everything becomes fairly simple.
+
+**The basic binary object is `ArrayBuffer` -- a reference to a fixed-length contiguos memory area.**
+
+We create it like this:
+```js run
+let buffer = new ArrayBuffer(16); // create a buffer of length 16
+alert(buffer.byteLength); // 16
+```
+
+This allocates a contiguous memory area of 16 bytes and pre-fills it with zeroes.
+
+```warn header="`ArrayBuffer` is not an array of something"
+Let's eliminate a possible source of confusion. `ArrayBuffer` has nothing in common with `Array`:
+- It has a fixed length, we can't increase or decrease it.
+- It takes exactly that much space in the memory.
+- To access individual bytes, another "view" object is needed, not `buffer[index]`.
+```
+
+`ArrayBuffer` is a memory area. What's stored in it? It has no clue. Just a raw sequence of bytes.
+
+**To manipulate an `ArrayBuffer`, we need to use a "view" object.**
+
+A view object does not store anything on it's own. It's the "eyeglasses" that give an interpretation of the bytes stored in the `ArrayBuffer`.
+
+For instance:
+
+- **`Uint8Array`** -- treats each byte in `ArrayBuffer` as a separate number, with possible values are from 0 to 255 (a byte is 8-bit, so it can hold only that much). Such value is called a "8-bit unsigned integer".
+- **`Uint16Array`** -- treats every 2 bytes as an integer, with possible values from 0 to 65535. That's called a "16-bit unsigned integer".
+- **`Uint32Array`** -- treats every 4 bytes as an integer, with possible values from 0 to 4294967295. That's called a "32-bit unsigned integer".
+- **`Float64Array`** -- treats every 8 bytes as a floating point number with possible values from <code>5.0x10<sup>-324</sup></code> to <code>1.8x10<sup>308</sup></code>.
+
+So, the binary data in an `ArrayBuffer` of 16 bytes can be interpreted as 16 "tiny numbers", or 8 bigger numbers (2 bytes each), or 4 even bigger (4 bytes each), or 2 floating-point values with high precision (8 bytes each).
+
+![](arraybuffer-views.png)
+
+`ArrayBuffer` is the core object, the root of everything, the raw binary data.
+
+But if we're going to write into it, or iterate over it, basically for almost any operation – we must use a view, e.g:
+
+```js run
+let buffer = new ArrayBuffer(16); // create a buffer of length 16
+
+*!*
+let view = new Uint32Array(buffer); // treat buffer as a sequence of 32-bit integers
+
+alert(Uint32Array.BYTES_PER_ELEMENT); // 4 bytes per integer
+*/!*
+
+alert(view.length); // 4, it stores that many integers
+alert(view.byteLength); // 16, the size in bytes
+
+// let's write a value
+view[0] = 123456;
+
+// iterate over values
+for(let num of view) {
+  alert(num); // 123456, then 0, 0, 0 (4 values total)
+}
+
+```
+
+## TypedArray
+
+The common term for all these views (`Uint8Array`, `Uint32Array`, etc) is [TypedArray](https://tc39.github.io/ecma262/#sec-typedarray-objects). They share the same set of methods and properities.
+
+They are much more like regular arrays: have indexes and iterable.
+
+
+A typed array constructor (be it `Int8Array` or `Float64Array`, doesn't matter) behaves differently depending on argument types.
+
+There are 5 variants of arguments:
+
+```js
+new TypedArray(buffer, [byteOffset], [length]);
+new TypedArray(object);
+new TypedArray(typedArray);
+new TypedArray(length);
+new TypedArray();
+```
+
+1. If an `ArrayBuffer` argument is supplied, the view is created over it. We used that syntax already.
+
+    Optionally we can provide `byteOffset` to start from (0 by default) and the `length` (till the end of the buffer by default), then the view will cover only a part of the `buffer`.
+
+2. If an `Array`, or any array-like object is given, it creates a typed array of the same length and copies the content.
+
+    We can use it to pre-fill the array with the data:
+    ```js run
+    *!*
+    let arr = new Uint8Array([0, 1, 2, 3]);
+    */!*
+    alert( arr.length ); // 4
+    alert( arr[1] ); // 1
+    ```
+3. If another `TypedArray` is supplied, it does the same: creates a typed array of the same length and copies values. Values are converted to the new type in the process.
+    ```js run
+    let arr16 = new Uint16Array([1, 1000]);
+    *!*
+    let arr8 = new Uint8Array(arr16);
+    */!*
+    alert( arr8[0] ); // 1
+    alert( arr8[1] ); // 232 (tried to copy 1000, but can't fit 1000 into 8 bits)
+    ```
+
+4. For a numeric argument `length` -- creates the typed array to contain that many elements. Its byte length will be `length` multiplied by the number of bytes in a single item `TypedArray.BYTES_PER_ELEMENT`:
+    ```js run
+    let arr = new Uint16Array(4); // create typed array for 4 integers
+    alert( Uint16Array.BYTES_PER_ELEMENT ); // 2 bytes per integer
+    alert( arr.byteLength ); // 8 (size in bytes)
+    ```
+
+5. Without arguments, creates an zero-length typed array.
+
+We can create a `TypedArray` directly, without mentioning `ArrayBuffer`. But a view cannot exist without an underlying `ArrayBuffer`, so gets created automatically in all these cases except the first one (when provided).
+
+To access the `ArrayBuffer`, there are properties:
+- `arr.buffer` -- references the `ArrayBuffer`.
+- `arr.byteLength` -- the length of the `ArrayBuffer`.
+
+So, we can always move from one view to another:
+```js
+let arr8 = new Uint8Array([0, 1, 2, 3]);
+
+// another view on the same data
+let arr16 = new Uint16Array(arr8.buffer);
+```
+
+
+Here's the list of typed arrays:
+
+- `Uint8Array`, `Uint16Array`, `Uint32Array` -- for integer numbers of 8, 16 and 32 bits.
+  - `Uint8ClampedArray` -- for 8-bit integers, "clamps" them on assignment (see below).
+- `Int8Array`, `Int16Array`, `Int32Array` -- for signed integer numbers (can be negative).
+- `Float32Array`, `Float64Array` -- for signed floating-point numbers of 32 and 64 bits.
+
+```warn header="No `int8` or similar single-valued types"
+Please note, despite of the names like `Int8Array`, there's no single-value type like `int`, or `int8` in JavaScript.
+
+That's logical, as `Int8Array` is not an array of these individual values, but rather a view on `ArrayBuffer`.
+```
+
+### Out-of-bounds behavior
+
+What if we attempt to write an out-of-bounds value into a typed array? There will be no error. But extra bits are cut-off.
+
+For instance, let's try to put 256 into `Uint8Array`. In binary form, 256 is `100000000` (9 bits), but `Uint8Array` only provides 8 bits per value, that makes the available range from 0 to 255.
+
+For bigger numbers, only the rightmost (less significant) 8 bits are stored, and the rest is cut off:
+
+![](8bit-integer-256.png)
+
+So we'll get zero.
+
+For 257, the binary form is `100000001` (9 bits), the rightmost 8 get stored, so we'll have `1` in the array:
+
+![](8bit-integer-257.png)
+
+In other words, the number modulo 2<sup>8</sup> is saved.
+
+Here's the demo:
+
+```js run
+let uint8array = new Uint8Array(16);
+
+let num = 256;
+alert(num.toString(2)); // 100000000 (binary representation)
+
+uint8array[0] = 256;
+uint8array[1] = 257;
+
+alert(uint8array[0]); // 0
+alert(uint8array[1]); // 1
+```
+
+`Uint8ClampedArray` is special in this aspect, its behavior is different. It saves 255 for any number that is greater than 255, and 0 for any negative number. That behavior is useful for image processing.
+
+## TypedArray methods
+
+`TypedArray` has regular `Array` methods, with notable exceptions.
+
+We can iterate, `map`, `slice`, `find`, `reduce` etc.
+
+There are few things we can't do though:
+
+- No `splice` -- we can't "delete" a value, because typed arrays are views on a buffer, and these are fixed, contiguous areas of memory. All we can do is to assign a zero.
+- No `concat` method.
+
+There are two additional methods:
+
+- `arr.set(fromArr, [offset])` copies all elements from `fromArr` to the `arr`, starting at position `offset` (0 by default).
+- `arr.subarray([begin, end])` creates a new view of the same type from `begin` to `end` (exclusive). That's similar to `slice` method (that's also supported), but doesn't copy anything -- just creates a new view, to operate on the given piece of data.
+
+These methods allow us to copy typed arrays, mix them, create new arrays from existing ones, and so on.
+
+
+
+## DataView
+
+[DataView](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView) is a special super-flexible "untyped" view over `ArrayBuffer`. It allows to access the data on any offset in any format.
+
+- For typed arrays, the constructor dictates what the format is. The whole array is supposed to be uniform. The i-th number is `arr[i]`.
+- With `DataView` we access the data with methods like `.getUint8(i)` or `.gteUint16(i)`. We choose the format at method call time instead of the construction time.
+
+The syntax:
+
+```js
+new DataView(buffer, [byteOffset], [byteLength])
+```
+
+- **`buffer`** -- the underlying `ArrayBuffer`. Unlike typed arrays, `DataView` doesn't create a buffer on its own. We need to have it ready.
+- **`byteOffset`** -- the starting byte position of the view (by default 0).
+- **`byteLength`** -- the byte length of the view (by default till the end of `buffer`).
+
+For instance, here we extract numbers in different formats from the same buffer:
+
+```js run
+let buffer = new Uint8Array([255, 255, 255, 255]).buffer;
+
+let dataView = new DataView(buffer);
+
+// get 8-bit number at offset 0
+alert( dataView.getUint8(0) ); // 255
+
+// now get 16-bit number at offset 0, that's 2 bytes, both with max value
+alert( dataView.getUint16(0) ); // 65535 (biggest 16-bit unsigned int)
+
+// get 32-bit number at offset 0
+alert( dataView.getUint32(0) ); // 4294967295 (biggest 32-bit unsigned int)
+
+dataView.setUint32(0, 0); // set 4-byte number to zero
+```
+
+`DataView` is great when we store mixed-format data in the same buffer. E.g we store a sequence of pairs (16-bit integer, 32-bit float). Then `DataView` allows to access them easily.
+
+## Summary
+
+`ArrayBuffer` is the core object, a reference to the fixed-length contiguous memory area.
+
+To do almost any operation on `ArrayBuffer`, we need a view.
+
+- It can be a `TypedArray`:
+    - `Uint8Array`, `Uint16Array`, `Uint32Array` -- for integer numbers of 8, 16 and 32 bits.
+    - `Uint8ClampedArray` -- for 8-bit integers, "clamps" them on assignment.
+    - `Int8Array`, `Int16Array`, `Int32Array` -- for signed integer numbers (can be negative).
+    - `Float32Array`, `Float64Array` -- for signed floating-point numbers of 32 and 64 bits.
+- Or a `DataView` -- the view that uses methods to specify a format, e.g. `getUint8(offset)`.
+
+In most cases we create and operate directly on typed arrays, leaving `ArrayBuffer` under cover, as a "common discriminator". We can access it as `.buffer` and make another view if needed.
+
+There are also two additional terms:
+- `ArrayBufferView` is an umbrella term for all these kinds of views.
+- `BufferSource` is an umbrella term for `ArrayBuffer` or `ArrayBufferView`.
+
+These are used in descriptions of methods that operate on binary data. `BufferSource` is one of the most common teerms, as it means "any kind of binary data" -- an `ArrayBuffer` or a view over it. 
+
+
+Here's a cheatsheet:
+
+![](arraybuffer-view-buffersource.png)
diff --git a/4-binary/02-text-decoder/article.md b/4-binary/02-text-decoder/article.md
new file mode 100644
index 000000000..9287279ec
--- /dev/null
+++ b/4-binary/02-text-decoder/article.md
@@ -0,0 +1,76 @@
+# TextDecoder and TextEncoder
+
+What if the binary data is actually a string? For instance, we received a file with textual data.
+
+The build-in [TextDecoder](https://encoding.spec.whatwg.org/#interface-textdecoder) object allows to read the value into an an actual JavaScript string, given the buffer and the encoding.
+
+We first need to create it:
+```js
+let decoder = new TextDecoder([label], [options]);
+```
+
+- **`label`** -- the encoding, `utf-8` by default, but `big5`, `windows-1251` and many other are also supported.
+- **`options`** -- optional object:
+  - **`fatal`** -- boolean, if `true` then throw an exception for invalid (non-decodable) characters, otherwise (default) replace them with character `\uFFFD`.
+  - **`ignoreBOM`** -- boolean, if `true` then ignore BOM (an optional byte-order unicode mark), rarely needed.
+
+...And then decode:
+
+```js
+let str = decoder.decode([input], [options]);
+```
+
+- **`input`** -- `BufferSource` to decode.
+- **`options`** -- optional object:
+  - **`stream`** -- true for decoding streams, when `decoder` is called repeatedly with incoming chunks of data. In that case a multi-byte character may occasionally split between chunks. This options tells `TextDecoder` to memorize "unfinished" characters and decode them when the next chunk comes.
+
+For instance:
+
+```js run
+let uint8Array = new Uint8Array([72, 101, 108, 108, 111]);
+
+alert( new TextDecoder().decode(uint8Array) ); // Hello
+```
+
+
+```js run
+let uint8Array = new Uint8Array([228, 189, 160, 229, 165, 189]);
+
+alert( new TextDecoder().decode(uint8Array) ); // 你好
+```
+
+We can decode a part of the buffer by creating a subarray view for it:
+
+
+```js run
+let uint8Array = new Uint8Array([0, 72, 101, 108, 108, 111, 0]);
+
+// the string is in the middle
+// create a new view over it, without copying anything
+let binaryString = uint8Array.subarray(1, -1);
+
+alert( new TextDecoder().decode(binaryString) ); // Hello
+```
+
+## TextEncoder
+
+[TextEncoder](https://encoding.spec.whatwg.org/#interface-textencoder) does the reverse thing -- converts a string into bytes.
+
+The syntax is:
+
+```js run
+let encoder = new TextEncoder();
+```
+
+The only encoding it supports is "utf-8".
+
+It has two methods:
+- **`encode(str)`** -- returns `Uint8Array` from a string.
+- **`encodeInto(str, destination)`** -- encodes `str` into `destination` that must be `Uint8Array`.
+
+```js run
+let encoder = new TextEncoder();
+
+let uint8Array = encoder.encode("Hello");
+alert(uint8Array); // 72,101,108,108,111
+```
diff --git a/4-binary/03-blob/article.md b/4-binary/03-blob/article.md
new file mode 100644
index 000000000..d75973ea7
--- /dev/null
+++ b/4-binary/03-blob/article.md
@@ -0,0 +1,239 @@
+# Blob
+
+`ArrayBuffer` and views are a part of ECMA standard, a part of JavaScript.
+
+In the browser, there are additional higher-level objects, described in [File API](https://www.w3.org/TR/FileAPI/).
+
+`Blob` consists of an optional string `type` (a MIME-type usually), plus `blobParts` -- a sequence of other `Blob` objects, strings and `BufferSources`.
+
+![](blob.png)
+
+Thanks to `type`, we can download/upload blobs, and it naturally becomes `Content-Type` in network requests.
+
+The constructor syntax is:
+
+```js
+new Blob(blobParts, options);
+```
+
+- **`blobParts`** is an array of `Blob`/`BufferSource`/`String` values.
+- **`options`** optional object:
+  - **`type`** -- blob type, usually MIME-type, e.g. `image/png`,
+  - **`endings`** -- whether to transform end-of-line to make the blob correspond to current OS newlines (`\r\n` or `\n`). By default `"transparent"` (do nothing), but also can be `"native"` (transform).
+
+For example:
+
+```js
+// create Blob from a string
+let blob = new Blob(["<html>…</html>"], {type: 'text/html'});
+// please note: the first argument must be an array [...]
+```
+
+```js
+// create Blob from a typed array and strings
+let hello = new Uint8Array([72, 101, 108, 108, 111]); // "hello" in binary form
+
+let blob = new Blob([hello, ' ', 'world'], {type: 'text/plain'});
+```
+
+
+We can extract blob slices with:
+
+```js
+blob.slice([byteStart], [byteEnd], [contentType]);
+```
+
+- **`byteStart`** -- the starting byte, by default 0.
+- **`byteEnd`** -- the last byte (exclusive, by default till the end).
+- **`contentType`** -- the `type` of the new blob, by default the same as the source.
+
+The arguments are similar to `array.slice`, negative numbers are allowed too.
+
+```smart header="Blobs are immutable"
+We can't change data directly in a blob, but we can slice parts of blobs, create new blobs from them, mix them into a new blob and so on.
+
+This behavior is similar to JavaScript strings: we can't change a character in a string, but we can make a new corrected string.
+```
+
+## Blob as URL
+
+A Blob can be easily used as an URL for `<a>`, `<img>` or other tags, to show its contents.
+
+Let's start with a simple example. By clicking on a link you download a dynamically-generated blob with `hello world` contents as a file:
+
+```html run
+<!-- download attribute forces the browser to download instead of navigating -->
+<a download="hello.txt" href='#' id="link">Download</a>
+
+<script>
+let blob = new Blob(["Hello, world!"], {type: 'text/plain'});
+
+link.href = URL.createObjectURL(blob);
+</script>
+```
+
+We can also create a link dynamically in JavaScript and simulate a click by `link.click()`, then download starts authomatically.
+
+Here's the similar "on the fly" blob creation and download code, but without HTML:
+
+```js run
+let link = document.createElement('a');
+link.download = 'hello.txt';
+
+let blob = new Blob(['Hello, world!'], {type: 'text/plain'});
+
+link.href = URL.createObjectURL(blob);
+
+link.click();
+
+URL.revokeObjectURL(link.href);
+```
+
+**`URL.createObjectURL` takes a blob and creates an unique URL for it, in the form `blob:<origin>/<uuid>`.**
+
+That's what the generated url looks like:
+
+```
+blob:https://javascript.info/1e67e00e-860d-40a5-89ae-6ab0cbee6273
+```
+
+The browser for each url generated by `URL.createObjectURL` stores an the url -> blob mapping internally. So such urls are short, but allow to access the blob.
+
+A generated url is only valid while the current document is open. And it allows to reference the blob in `<img>`, `<a>`, any other object that expects an url.
+
+There's a side-effect though. While there's an mapping for a blob, the blob itself resides in the memory. The browser can't free it.
+
+The mapping is automatically cleared on document unload, so blobs are freed then. But if an app is long-living, then that doesn't happen soon. So if we create an URL, that blob will hang in memory, even if not needed any more.
+
+**`URL.revokeObjectURL(url)` removes the reference from the internal mapping, thus allowing the blob to be deleted (if there are no other references), and the memory to be freed.**
+
+In the last example, we intend the blob to be used only once, for instant downloading, so we call `URL.revokeObjectURL(link.href)` immediately.
+
+In the previous example though, with the clickable HTML-link, we don't call `URL.revokeObjectURL(link.href)`, because that would make the blob url invalid. After the revocation, as the mapping is removed, the url doesn't work any more.
+
+## Blob to base64
+
+An alternative to `URL.createObjectURL` is to convert a blob into a base64-encoded string.
+
+That encoding represents binary data as a string of ultra-safe "readable" characters with ASCII-codes from 0 to 64. And what's more important -- we can use this encoding in "data-urls".
+
+A [data url](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs) has the form `data:[<mediatype>][;base64],<data>`. We can use such urls everywhere, on par with "regular" urls.
+
+For instance, here's a smiley:
+
+```html
+<img src="data:image/png;base64,R0lGODlhDAAMAKIFAF5LAP/zxAAAANyuAP/gaP///wAAAAAAACH5BAEAAAUALAAAAAAMAAwAAAMlWLPcGjDKFYi9lxKBOaGcF35DhWHamZUW0K4mAbiwWtuf0uxFAgA7">
+```
+
+The browser will decode the string and show the image: <img src="data:image/png;base64,R0lGODlhDAAMAKIFAF5LAP/zxAAAANyuAP/gaP///wAAAAAAACH5BAEAAAUALAAAAAAMAAwAAAMlWLPcGjDKFYi9lxKBOaGcF35DhWHamZUW0K4mAbiwWtuf0uxFAgA7">
+
+
+To transform a blob into base64, we'll use the built-in `FileReader` object. It can read data from Blobs in multiple formats. In the [next chapter](info:file) we'll cover it more in-depth.
+
+Here's the demo of downloading a blob, now via base-64:
+
+```js run
+let link = document.createElement('a');
+link.download = 'hello.txt';
+
+let blob = new Blob(['Hello, world!'], {type: 'text/plain'});
+
+*!*
+let reader = new FileReader();
+reader.readAsDataURL(blob); // converts the blob to base64 and calls onload
+*/!*
+
+reader.onload = function() {
+  link.href = reader.result; // data url
+  link.click();
+};
+```
+
+Both ways of making an URL of a blob are usable. But usually `URL.createObjectURL(blob)` is simpler and faster.
+
+```compare title-plus="URL.createObjectURL(blob)" title-minus="Blob to data url"
++ We need to revoke them if care about memory.
++ Direct access to blob, no "encoding/decoding"
+- No need to revoke anything.
+- Performance and memory losses on big blobs for encoding.
+```
+
+## Image to blob
+
+We can create a blob of an image, an image part, or even make a page screenshot. That's handy to upload it somewhere.
+
+Image operations are done via `<canvas>` element:
+
+1. Draw an image (or its part) on canvas using [canvas.drawImage](https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/drawImage).
+2. Call canvas method [.toBlob(callback, format, quality)](https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob) that creates a blob and runs `callback` with it when done.
+
+In the example below, an image is just copied, but we could cut from it, or transform it on canvas prior to making a blob:
+
+```js run
+// take any image
+let img = document.querySelector('img');
+
+// make <canvas> of the same size
+let canvas = document.createElement('canvas');
+canvas.width = img.clientWidth;
+canvas.height = img.clientHeight;
+
+let context = canvas.getContext('2d');
+
+// copy image to it (this method allows to cut image)
+context.drawImage(img, 0, 0);
+// we can context.rotate(), and do many other things on canvas
+
+// toBlob is async opereation, callback is called when done
+canvas.toBlob(function(blob) {
+  // blob ready, download it
+  let link = document.createElement('a');
+  link.download = 'example.png';
+
+  link.href = URL.createObjectURL(blob);
+  link.click();
+
+  // delete the internal blob reference, to let the browser clear memory from it
+  URL.revokeObjectURL(link.href);
+}, 'image/png');
+```
+
+If we prefer `async/await` instead of callbacks:
+```js
+let blob = await new Promise(resolve => canvasElem.toBlob(resolve, 'image/png'));
+```
+
+For screenshotting a page, we can use a library such as <https://github.com/niklasvh/html2canvas>. What it does is just walks the page and draws it on `<canvas>`. Then we can get a blob of it the same way as above.
+
+## From Blob to ArrayBuffer
+
+The `Blob` constructor allows to create a blob from almost anything, including any `BufferSource`.
+
+But if we need to perform low-level processing, we can get the lowest-level `ArrayBuffer` from it using `FileReader`:
+
+```js
+// get arrayBuffer from blob
+let fileReader = new FileReader();
+
+*!*
+fileReader.readAsArrayBuffer(blob);
+*/!*
+
+fileReader.onload = function(event) {
+  let arrayBuffer = fileReader.result;
+};
+```
+
+
+## Summary
+
+While `ArrayBuffer`, `Uint8Array` and other `BufferSource` are "binary data", a [Blob](https://www.w3.org/TR/FileAPI/#dfn-Blob) represents "binary data with type".
+
+That makes Blobs convenient for upload/download operations, that are so common in the browser.
+
+Methods that perform web-requests, such as [XMLHttpRequest](info:xmlhttprequest), [fetch](info:fetch-basics) and so on, can work with `Blob` natively, as well as with other binary types.
+
+We can easily convert betweeen `Blob` and low-level binary data types:
+
+- We can make a Blob from a typed array using `new Blob(...)` constructor.
+- We can get back `ArrayBuffer` from a Blob using `FileReader`, and then create a view over it for low-level binary processing.
diff --git a/4-binary/03-blob/blob.png b/4-binary/03-blob/blob.png
new file mode 100644
index 000000000..cd0974f49
Binary files /dev/null and b/4-binary/03-blob/blob.png differ
diff --git a/4-binary/03-blob/blob@2x.png b/4-binary/03-blob/blob@2x.png
new file mode 100644
index 000000000..519bdf885
Binary files /dev/null and b/4-binary/03-blob/blob@2x.png differ
diff --git a/4-binary/04-file/article.md b/4-binary/04-file/article.md
new file mode 100644
index 000000000..e9a01b1b4
--- /dev/null
+++ b/4-binary/04-file/article.md
@@ -0,0 +1,128 @@
+# File and FileReader
+
+A [File](https://www.w3.org/TR/FileAPI/#dfn-file) object inhereits from `Blob`, but is extended with filesystem-related capabilities.
+
+There are two ways to obtain it.
+
+First, there's a constructor, similar to `Blob`:
+
+```js
+new File(fileParts, fileName, [options])
+```
+
+- **`fileParts`** -- is an array of Blob/BufferSource/String value, same as `Blob`.
+- **`fileName`** -- file name string.
+- **`options`** -- optional object:
+    - **`lastModified`** -- a timestamp (integer date) of last modification.
+
+Second, more often we get a file from `<input type="file">` or drag'n'drop or other browser interfaces. Then the file gets these from OS.
+
+For instance:
+
+```html run
+<input type="file" onchange="showFile(this)">
+
+<script>
+function showFile(input) {
+  let file = input.files[0];
+
+  alert(`File name: ${file.name}`); // e.g my.png
+  alert(`Last modified: ${file.lastModified}`); // e.g 1552830408824
+}
+</script>
+```
+
+```smart
+The input may select multiple files, so `input.files` is an array-like object with them. Here we have only one file, so we just take `input.files[0]`.
+```
+
+## FileReader
+
+[FileReader](https://www.w3.org/TR/FileAPI/#dfn-filereader) is an object with the sole purpose of reading from `Blob` (and hence `File` too) objects.
+
+It's event based, as reading from disk may take time.
+
+The constructor:
+
+```js
+let reader = new FileReader(); // no arguments
+```
+
+The main methods:
+
+- **`readAsArrayBuffer(blob)`** -- read the data as `ArrayBuffer`
+- **`readAsText(blob, [encoding])`** -- read the data as a string (encoding is `utf-8` by default)
+- **`readAsDataURL(blob)`** -- encode the data as base64 data url.
+- **`abort()`** -- cancel the operation.
+
+As the reading proceeds, there are events:
+- `loadstart` -- loading started.
+- `progress` -- occurs during reading.
+- `load` -- no errors, reading complete.
+- `abort` -- `abort()` called.
+- `error` -- error has occured.
+- `loadend` -- reading finished with either success or failure.
+
+When the reading is finished, we can access the result as:
+- `reader.result` is the result (if successful)
+- `reader.error` is the error (if failed).
+
+The most widely used events are for sure `load` and `error`.
+
+Here's an example of reading a file:
+
+```html run
+<input type="file" onchange="readFile(this)">
+
+<script>
+function readFile(input) {
+  let file = input.files[0];
+
+  let reader = new FileReader();
+
+  reader.readAsText(file);
+
+  reader.onload = function() {
+    console.log(reader.result);
+  };
+
+  reader.onerror = function() {
+    console.log(reader.error);
+  };
+
+}
+</script>
+```
+
+```smart header="`FileReader` for blobs"
+As mentioned in the chapter <info:blob>, `FileReader` works for any blobs, not just files.
+
+So we can use it to convert a blob to another format:
+- `readAsArrayBuffer(blob)` -- to `ArrayBuffer`,
+- `readAsText(blob, [encoding])` -- to string (an alternative to `TextDecoder`),
+- `readAsDataURL(blob)` -- to base64 data url.
+```
+
+
+```smart header="`FileReaderSync` is available for workers only"
+For Web Workers, there also exists a synchronous variant of `FileReader`, called [FileReaderSync](https://www.w3.org/TR/FileAPI/#FileReaderSync).
+
+Its reading methods `read*` do not generate events, but rather return a result, as regular functions do.
+
+That's only inside a Web Worker though, because delays and hang-ups in Web Workers are less important, they do not affect the page.
+```
+
+## Summary
+
+`File` object inherit from `Blob`.
+
+In addition to `Blob` methods and properties, `File` objects also have `fileName` and `lastModified` properties, plus the internal ability to read from filesystem. We usually get `File` objects from user input, like `<input>` or drag'n'drop.
+
+`FileReader` objects can read from a file or a blob, in one of three formats:
+- String (`readAsText`).
+- `ArrayBuffer` (`readAsArrayBuffer`).
+- Data url, base-64 encoded (`readAsDataURL`).
+
+In many cases though, we don't have to read the file contents. Just as we did with blobs, we can create a short url with `URL.createObjectURL(file)` and assign it to `<a>` or `<img>`. This way the file can be downloaded or shown up as an image, as a part of canvas etc.
+
+And if we're going to send a `File` over a network, that's also easy, as network API like `XMLHttpRequest` or `fetch` natively accepts `File` objects.
diff --git a/4-binary/index.md b/4-binary/index.md
new file mode 100644
index 000000000..2b0c5dc82
--- /dev/null
+++ b/4-binary/index.md
@@ -0,0 +1,3 @@
+# Binary data, files
+
+Working with binary data and files in JavaScript.
diff --git a/5-network/01-fetch-basics/article.md b/5-network/01-fetch-basics/article.md
new file mode 100644
index 000000000..783c39962
--- /dev/null
+++ b/5-network/01-fetch-basics/article.md
@@ -0,0 +1,361 @@
+
+# Fetch: Basics
+
+Method `fetch()` is the modern way of sending requests over HTTP.
+
+It evolved for several years and continues to improve, right now the support is pretty solid among browsers.
+
+The basic syntax is:
+
+```js
+let promise = fetch(url, [options])
+```
+
+- **`url`** -- the URL to access.
+- **`options`** -- optional parameters: method, headers etc.
+
+The browser starts the request right away and returns a `promise`.
+
+Getting a response is usually a two-stage process.
+
+**The `promise` resolves with an object of the built-in [Response](https://fetch.spec.whatwg.org/#response-class) class as soon as the server responds with headers.**
+
+
+So we can check HTTP status, to see whether it is successful or not, check headers, but don't have the body yet.
+
+The promise rejects if the `fetch` was unable to make HTTP-request, e.g. network problems, or there's no such site. HTTP-errors, even such as 404 or 500, are considered a normal flow.
+
+We can see them in response properties:
+
+- **`ok`** -- boolean, `true` if the HTTP status code is 200-299.
+- **`status`** -- HTTP status code.
+
+For example:
+
+```js
+let response = await fetch(url);
+
+if (response.ok) { // if HTTP-status is 200-299
+  // get the response body (see below)
+  let json = await response.json();
+} else {
+  alert("HTTP-Error: " + response.status);
+}
+```
+
+To get the response body, we need to use an additional method call.
+
+`Response` provides multiple promise-based methods to access the body in various formats:
+
+- **`response.json()`** -- parse the response as JSON object,
+- **`response.text()`** -- return the response as text,
+- **`response.formData()`** -- return the response as FormData object (form/multipart encoding),
+- **`response.blob()`** -- return the response as [Blob](info:blob) (binary data with type),
+- **`response.arrayBuffer()`** -- return the response as [ArrayBuffer](info:arraybuffer-binary-arrays) (pure binary data),
+- additionally, `response.body` is a [ReadableStream](https://streams.spec.whatwg.org/#rs-class) object, it allows to read the body chunk-by-chunk, we'll see an example later.
+
+For instance, here we get a JSON-object with latest commits from GitHub:
+
+```js run async
+let response = await fetch('https://api.github.com/repos/javascript-tutorial/en.javascript.info/commits');
+
+*!*
+let commits = await response.json(); // read response body and parse as JSON
+*/!*
+
+alert(commits[0].author.login);
+```
+
+Or, the same using pure promises syntax:
+
+```js run
+fetch('https://api.github.com/repos/javascript-tutorial/en.javascript.info/commits')
+  .then(response => response.json())
+  .then(commits => alert(commits[0].author.login));
+```
+
+To get the text:
+```js
+let text = await response.text();
+```
+
+And for the binary example, let's fetch and show an image (see chapter [Blob](info:blob) for details about operations on blobs):
+
+```js async run
+let response = await fetch('/article/fetch/logo-fetch.svg');
+
+*!*
+let blob = await response.blob(); // download as Blob object
+*/!*
+
+// create <img> for it
+let img = document.createElement('img');
+img.style = 'position:fixed;top:10px;left:10px;width:100px';
+document.body.append(img);
+
+// show it
+img.src = URL.createObjectURL(blob);
+
+setTimeout(() => { // hide after two seconds
+  img.remove();
+  URL.revokeObjectURL(img.src);
+}, 2000);
+```
+
+````warn
+We can choose only one body-parsing method.
+
+If we got the response with `response.text()`, then `response.json()` won't work, as the body content has already been processed.
+
+```js
+let text = await response.text(); // response body consumed
+let parsed = await response.json(); // fails (already consumed)
+````
+
+## Headers
+
+There's a Map-like headers object in `response.headers`.
+
+We can get individual headers or iterate over them:
+
+```js run async
+let response = await fetch('https://api.github.com/repos/javascript-tutorial/en.javascript.info/commits');
+
+// get one header
+alert(response.headers.get('Content-Type')); // application/json; charset=utf-8
+
+// iterate over all headers
+for (let [key, value] of response.headers) {
+  alert(`${key} = ${value}`);
+}
+```
+
+To set a header, we can use the `headers` option, like this:
+
+```js
+let response = fetch(protectedUrl, {
+  headers: {
+    Authentication: 'abcdef'
+  }
+});
+```
+
+...But there's a list of [forbidden HTTP headers](https://fetch.spec.whatwg.org/#forbidden-header-name) that we can't set:
+
+- `Accept-Charset`, `Accept-Encoding`
+- `Access-Control-Request-Headers`
+- `Access-Control-Request-Method`
+- `Connection`
+- `Content-Length`
+- `Cookie`, `Cookie2`
+- `Date`
+- `DNT`
+- `Expect`
+- `Host`
+- `Keep-Alive`
+- `Origin`
+- `Referer`
+- `TE`
+- `Trailer`
+- `Transfer-Encoding`
+- `Upgrade`
+- `Via`
+- `Proxy-*`
+- `Sec-*`
+
+These headers ensure proper and safe HTTP, so they are controlled exclusively by the browser.
+
+## POST requests
+
+To make a `POST` request, or a request with another method, we need to use `fetch` options:
+
+- **`method`** -- HTTP-method, e.g. `POST`,
+- **`body`** -- one of:
+  - a string (e.g. JSON),
+  - `FormData` object, to submit the data as `form/multipart`,
+  - `Blob`/`BufferSource` to send binary data,
+  - [URLSearchParams](info:url), to submit the data as `x-www-form-urlencoded`, rarely used.
+
+Let's see examples.
+
+## Submit JSON
+
+This code submits a `user` object as JSON:
+
+```js run async
+let user = {
+  name: 'John',
+  surname: 'Smith'
+};
+
+*!*
+let response = await fetch('/article/fetch-basics/post/user', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json;charset=utf-8'
+  },
+  body: JSON.stringify(user)
+});
+*/!*
+
+let result = await response.json();
+alert(result.message);
+```
+
+Please note, if the body is a string, then `Content-Type` is set to `text/plain;charset=UTF-8` by default. So we use `headers` option to send `application/json` instead.
+
+## Submit a form
+
+Let's do the same with an HTML `<form>`.
+
+
+```html run
+<form id="formElem">
+  <input type="text" name="name" value="John">
+  <input type="text" name="surname" value="Smith">
+</form>
+
+<script>
+(async () => {
+  let response = await fetch('/article/fetch-basics/post/user', {
+    method: 'POST',
+*!*
+    body: new FormData(formElem)
+*/!*
+  });
+
+  let result = await response.json();
+
+  alert(result.message);
+})();
+</script>
+```
+
+Here [FormData](https://xhr.spec.whatwg.org/#formdata) automatically encodes the form, `<input type="file">` fields are handled also, and sends it using `Content-Type: form/multipart`.
+
+## Submit an image
+
+We can also submit binary data directly using `Blob` or `BufferSource`.
+
+For example, here's a `<canvas>` where we can draw by moving a mouse. A click on the "submit" button sends the image to server:
+
+```html run autorun height="90"
+<body style="margin:0">
+  <canvas id="canvasElem" width="100" height="80" style="border:1px solid"></canvas>
+
+  <input type="button" value="Submit" onclick="submit()">
+
+  <script>
+    canvasElem.onmousemove = function(e) {
+      let ctx = canvasElem.getContext('2d');
+      ctx.lineTo(e.clientX, e.clientY);
+      ctx.stroke();
+    };
+
+    async function submit() {
+      let blob = await new Promise(resolve => canvasElem.toBlob(resolve, 'image/png'));
+      let response = await fetch('/article/fetch-basics/post/image', {
+        method: 'POST',
+        body: blob
+      });
+      let result = await response.json();
+      alert(result.message);
+    }
+
+  </script>
+</body>
+```
+
+Here we also didn't need to set `Content-Type` manually, because a `Blob` object has a built-in type (here `image/png`, as generated by `toBlob`).
+
+The `submit()` function can be rewritten without `async/await` like this:
+
+```js
+function submit() {
+  canvasElem.toBlob(function(blob) {        
+    fetch('/article/fetch-basics/post/image', {
+      method: 'POST',
+      body: blob
+    })
+      .then(response => response.json())
+      .then(result => alert(JSON.stringify(result, null, 2)))
+  }, 'image/png');
+}
+```
+
+## Custom FormData with image
+
+In practice though, it's often more convenient to send an image as a part of the form, with additional fields, such as "name" and other metadata.
+
+Also, servers are usually more suited to accept multipart-encoded forms, rather than raw binary data.
+
+```html run autorun height="90"
+<body style="margin:0">
+  <canvas id="canvasElem" width="100" height="80" style="border:1px solid"></canvas>
+
+  <input type="button" value="Submit" onclick="submit()">
+
+  <script>
+    canvasElem.onmousemove = function(e) {
+      let ctx = canvasElem.getContext('2d');
+      ctx.lineTo(e.clientX, e.clientY);
+      ctx.stroke();
+    };
+
+    async function submit() {
+      let blob = await new Promise(resolve => canvasElem.toBlob(resolve, 'image/png'));
+
+*!*
+      let formData = new FormData();
+      formData.append("name", "myImage");
+      formData.append("image", blob);
+*/!*    
+
+      let response = await fetch('/article/fetch-basics/post/image-form', {
+        method: 'POST',
+        body: formData
+      });
+      let result = await response.json();
+      alert(result.message);
+    }
+
+  </script>
+</body>
+```
+
+Now, from the server standpoint, the image is a "file" in the form.
+
+## Summary
+
+A typical fetch request consists of two `awaits`:
+
+```js
+let response = await fetch(url, options); // resolves with response headers
+let result = await response.json(); // read body as json
+```
+
+Or, promise-style:
+```js
+fetch(url, options)
+  .then(response => response.json())
+  .then(result => /* process result */)
+```
+
+Response properties:
+- `response.status` -- HTTP code of the response,
+- `response.ok` -- `true` is the status is 200-299.
+- `response.headers` -- Map-like object with HTTP headers.
+
+Methods to get response body:
+- **`response.json()`** -- parse the response as JSON object,
+- **`response.text()`** -- return the response as text,
+- **`response.formData()`** -- return the response as FormData object (form/multipart encoding),
+- **`response.blob()`** -- return the response as [Blob](info:blob) (binary data with type),
+- **`response.arrayBuffer()`** -- return the response as [ArrayBuffer](info:arraybuffer-binary-arrays) (pure binary data),
+
+Fetch options so far:
+- `method` -- HTTP-method,
+- `headers` -- an object with request headers (not any header is allowed),
+- `body` -- string/FormData/BufferSource/Blob/UrlSearchParams data to submit.
+
+In the next chapters we'll see more options and use cases.
diff --git a/5-network/01-fetch-basics/logo-fetch.svg b/5-network/01-fetch-basics/logo-fetch.svg
new file mode 100644
index 000000000..5a58b209b
--- /dev/null
+++ b/5-network/01-fetch-basics/logo-fetch.svg
@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+<circle cx="50" cy="50" r="45" fill="#fff" stroke="#3c790a" stroke-width="10"/>
+<path d="m34,55a60,60,0,0,0,20,-20a6,10,0,0,1,13,-1a10,6,0,0,1,-1,13a60,60,0,0,0,-20,20a6,10,0,0,1,-13,1a10,6,0,0,1,1,-13" fill="#3c790a"/>
+</svg>
diff --git a/5-network/01-fetch-basics/post.view/server.js b/5-network/01-fetch-basics/post.view/server.js
new file mode 100644
index 000000000..18610676a
--- /dev/null
+++ b/5-network/01-fetch-basics/post.view/server.js
@@ -0,0 +1,57 @@
+const Koa = require('koa');
+const app = new Koa();
+const bodyParser = require('koa-bodyparser');
+const getRawBody = require('raw-body')
+const busboy = require('async-busboy');
+const Router = require('koa-router');
+
+let router = new Router();
+
+router.post('/user', async (ctx) => {
+  ctx.body = {
+    message: "User saved."
+  };
+});
+
+router.post('/image', async (ctx) => {
+  let body = await getRawBody(ctx.req, {
+    limit: '1mb'
+  });
+  ctx.body = {
+    message: `Image saved, size:${body.length}.`
+  };
+});
+
+router.post('/image-form', async (ctx) => {
+
+  let files = [];
+  const { fields } = await busboy(ctx.req, {
+    onFile(fieldname, file, filename, encoding, mimetype) {
+      // read all file stream to continue
+      getRawBody(file, { limit: '1mb'}).then(body => {
+        files.push({
+          fieldname,
+          filename,
+          length: body.length
+        }); 
+      })
+
+    }
+  });
+
+  ctx.body = {
+    message: `Image saved, name: ${fields.name}, size:${files[0].length}.`
+  };
+});
+
+app
+  .use(bodyParser())
+  .use(router.routes())
+  .use(router.allowedMethods());
+
+
+if (!module.parent) {
+  http.createServer(app.callback()).listen(8080);
+} else {
+  exports.accept = app.callback();
+}
diff --git a/5-network/02-fetch-progress/article.md b/5-network/02-fetch-progress/article.md
new file mode 100644
index 000000000..e7e945f66
--- /dev/null
+++ b/5-network/02-fetch-progress/article.md
@@ -0,0 +1,104 @@
+
+# Fetch: Download progress
+
+Fetch allows to track download progress, but not upload progress.
+
+Please note: there's currently no way for fetch to track upload progress. For that purpose, please use [XMLHttpRequest](info:xmlhttprequest).
+
+To track download progress, we can use `response.body` property. It's a "readable stream" -- a special object that provides body chunk-by-chunk, as it comes, so we can see how much is available at the moment.
+
+Here's the sketch of code that uses it to read response:
+
+```js
+// instead of response.json() and other methods
+const reader = response.body.getReader();
+
+// infinite loop while the body is downloading
+while(true) {
+  // done is true for the last chunk
+  // value is Uint8Array of the chunk bytes
+  const {done, value} = await reader.read();
+
+  if (done) {
+    break;
+  }
+
+  console.log(`Received ${value.length} bytes`)
+}
+```
+
+So, we loop, while `await reader.read()` returns response chunks.
+
+A chunk has two properties:
+- **`done`** -- true when the reading is complete.
+- **`value`** -- a typed array of bytes: `Uint8Array`.
+
+To log the progress, we just need to count chunks.
+
+Here's the full code to get response and log the progress, more explanations follow:
+
+```js run async
+// Step 1: start the fetch and obtain a reader
+let response = await fetch('https://api.github.com/repos/javascript-tutorial/en.javascript.info/commits?per_page=100');
+
+const reader = response.body.getReader();
+
+// Step 2: get total length
+const contentLength = +response.headers.get('Content-Length');
+
+// Step 3: read the data
+let receivedLength = 0; // length at the moment
+let chunks = []; // array of received binary chunks (comprises the body)
+while(true) {
+  const {done, value} = await reader.read();
+
+  if (done) {
+    break;
+  }
+
+  chunks.push(value);
+  receivedLength += value.length;
+
+  console.log(`Received ${receivedLength} of ${contentLength}`)
+}
+
+// Step 4: concatenate chunks into single Uint8Array
+let chunksAll = new Uint8Array(receivedLength); // (4.1)
+let position = 0;
+for(let chunk of chunks) {
+	chunksAll.set(chunk, position); // (4.2)
+	position += chunk.length;
+}
+
+// Step 5: decode into a string
+let result = new TextDecoder("utf-8").decode(chunksAll);
+
+// We're done!
+let commits = JSON.parse(result);
+alert(commits[0].author.login);
+```
+
+Let's explain that step-by-step:
+
+1. We perform `fetch` as usual, but instead of calling `response.json()`, we obtain a stream reader `response.body.getReader()`.
+
+    Please note, we can't use both these methods to read the same response. Either use a reader or a response method to get the result.
+2. Prior to reading, we can figure out the full response length from the `Content-Length` header.
+
+    It may be absent for cross-domain requests (see chapter <info:fetch-crossorigin>) and, well, technically a server doesn't have to set it. But usually it's at place.
+3. Call `await reader.read()` until it's done.
+
+    We gather response `chunks` in the array. That's important, because after the response is consumed, we won't be able to "re-read" it using `response.json()` or another way (you can try, there'll be an error).
+4. At the end, we have `chunks` -- an array of `Uint8Array` byte chunks. We need to join them into a single result. Unfortunately, there's no single method that concatenates those, so there's some code to do that:
+    1. We create `new Uint8Array(receivedLength)` -- a same-typed array with the combined length.
+    2. Then use `.set(chunk, position)` method to copy each `chunk` one after another in the resulting array.
+5. We have the result in `chunksAll`. It's a byte array though, not a string.
+
+    To create a string, we need to interpret these bytes. The built-in [TextDecoder](info:text-decoder) does exactly that. Then we can `JSON.parse` it.
+
+What if we need binary content instead of JSON? That's even simpler. Instead of steps 4 and 5, we could make a blob of all chunks:
+```js
+let blob = new Blob(chunks);
+```
+
+Once again, please note, that's not for upload progress (no way now), only for download progress.
diff --git a/5-network/02-fetch-progress/logo-fetch.svg b/5-network/02-fetch-progress/logo-fetch.svg
new file mode 100644
index 000000000..5a58b209b
--- /dev/null
+++ b/5-network/02-fetch-progress/logo-fetch.svg
@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+<circle cx="50" cy="50" r="45" fill="#fff" stroke="#3c790a" stroke-width="10"/>
+<path d="m34,55a60,60,0,0,0,20,-20a6,10,0,0,1,13,-1a10,6,0,0,1,-1,13a60,60,0,0,0,-20,20a6,10,0,0,1,-13,1a10,6,0,0,1,1,-13" fill="#3c790a"/>
+</svg>
diff --git a/5-network/02-fetch-progress/progress.view/index.html b/5-network/02-fetch-progress/progress.view/index.html
new file mode 100644
index 000000000..ba7f76065
--- /dev/null
+++ b/5-network/02-fetch-progress/progress.view/index.html
@@ -0,0 +1,36 @@
+<!doctype html>
+<script>
+(async () {
+	
+	const response = await fetch('long.txt');
+	const reader = response.body.getReader();
+
+	const contentLength = +response.headers.get('Content-Length');
+	let receivedLength = 0;
+	let chunks = [];
+	while(true) {
+		const chunk = await reader.read();
+
+		if (chunk.done) {
+			console.log("done!");
+			break;
+		}
+
+		chunks.push(chunk.value);
+		receivedLength += chunk.value.length;
+		console.log(`${receivedLength}/${contentLength} received`)
+	}
+
+
+	let chunksMerged = new Uint8Array(receivedLength);
+	let length = 0;
+	for(let chunk of chunks) {
+		chunksMerged.set(chunk, length);
+		length += chunk.length;
+	}
+
+	let result = new TextDecoder("utf-8").decode(chunksMerged);
+	console.log(result);
+})();
+
+</script>
diff --git a/5-network/02-fetch-progress/progress.view/long.txt b/5-network/02-fetch-progress/progress.view/long.txt
new file mode 100644
index 000000000..a98e50a28
--- /dev/null
+++ b/5-network/02-fetch-progress/progress.view/long.txt
@@ -0,0 +1,20465 @@
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
+A long file. Длинный файл. 长文件.
diff --git a/5-network/03-fetch-abort/article.md b/5-network/03-fetch-abort/article.md
new file mode 100644
index 000000000..3e6f4cb42
--- /dev/null
+++ b/5-network/03-fetch-abort/article.md
@@ -0,0 +1,110 @@
+
+# Fetch: Abort
+
+Aborting a `fetch` is a little bit tricky. Remember, `fetch` returns a promise. And JavaScript generally has no concept of "aborting" a promise. So how can we cancel a fetch?
+
+There's a special built-in object for such purposes: `AbortController`.
+
+The usage is pretty simple:
+
+- Step 1: create a controller:
+
+    ```js
+    let controller = new AbortController();
+    ```
+
+    A controller is an extremely simple object. It has a single method `abort()`, and a single property `signal`. When `abort()` is called, the `abort` event triggers on `controller.signal`:
+
+    Like this:
+
+    ```js run
+    let controller = new AbortController();
+    let signal = controller.signal;
+
+    // triggers when controller.abort() is called
+    signal.addEventListener('abort', () => alert("abort!"));
+
+    controller.abort(); // abort!
+
+    alert(signal.aborted); // true (after abort)
+    ```
+
+- Step 2: pass the `signal` property to `fetch` option:
+
+    ```js
+    let controller = new AbortController();
+    fetch(url, {
+      signal: controller.signal
+    });
+    ```
+
+    Now `fetch` listens to the signal.
+
+- Step 3: to abort, call `controller.abort()`:
+
+    ```js
+    controller.abort();
+    ```
+
+    We're done: `fetch` gets the event from `signal` and aborts the request.
+
+When a fetch is aborted, its promise rejects with an error named `AbortError`, so we should handle it:
+
+```js run async
+// abort in 1 second
+let controller = new AbortController();
+setTimeout(() => controller.abort(), 1000);
+
+try {
+  let response = await fetch('/article/fetch-abort/demo/hang', {
+    signal: controller.signal
+  });
+} catch(err) {
+  if (err.name == 'AbortError') { // handle abort()
+    alert("Aborted!");
+  } else {
+    throw err;
+  }
+}
+```
+
+**`AbortController` is scalable, it allows to cancel multiple fetches at once.**
+
+For instance, here we fetch many `urls` in parallel, and the controller aborts them all:
+
+```js
+let urls = [...]; // a list of urls to fetch in parallel
+
+let controller = new AbortController();
+
+let fetchJobs = urls.map(url => fetch(url, {
+  signal: controller.signal
+}));
+
+let results = await Promise.all(fetchJobs);
+
+// from elsewhere:
+// controller.abort() stops all fetches
+```
+
+If we have our own jobs, different from `fetch`, we can use a single `AbortController` to stop those, together with fetches.
+
+
+```js
+let urls = [...];
+let controller = new AbortController();
+
+let ourJob = new Promise((resolve, reject) => {
+  ...
+  controller.signal.addEventListener('abort', reject);
+});
+
+let fetchJobs = urls.map(url => fetch(url, {
+  signal: controller.signal
+}));
+
+let results = await Promise.all([...fetchJobs, ourJob]);
+
+// from elsewhere:
+// controller.abort() stops all fetches and ourJob
+```
diff --git a/5-network/03-fetch-abort/demo.view/server.js b/5-network/03-fetch-abort/demo.view/server.js
new file mode 100644
index 000000000..5a0c8e4a5
--- /dev/null
+++ b/5-network/03-fetch-abort/demo.view/server.js
@@ -0,0 +1,21 @@
+const Koa = require('koa');
+const app = new Koa();
+
+const Router = require('koa-router');
+
+let router = new Router();
+
+router.get('/hang', async (ctx) => {
+  await new Promise(() => {});
+});
+
+app
+  .use(router.routes())
+  .use(router.allowedMethods());
+
+
+if (!module.parent) {
+  http.createServer(app.callback()).listen(8080);
+} else {
+  exports.accept = app.callback();
+}
diff --git a/5-network/04-fetch-crossorigin/1-do-we-need-origin/solution.md b/5-network/04-fetch-crossorigin/1-do-we-need-origin/solution.md
new file mode 100644
index 000000000..8cbb2c88a
--- /dev/null
+++ b/5-network/04-fetch-crossorigin/1-do-we-need-origin/solution.md
@@ -0,0 +1,9 @@
+We need `Origin`, because sometimes `Referer` is absent. For instance, when we `fetch` HTTP-page from HTTPS (access less secure from more secure), then there's no `Referer`.
+
+The [Content Security Policy](http://en.wikipedia.org/wiki/Content_Security_Policy) may forbid sending a `Referer`.
+
+As we'll see, `fetch` also has options that prevent sending the `Referer` and even allow to change it (within the same site).
+
+By specification, `Referer` is an optional HTTP-header.
+
+Exactly because `Referer` is unreliable, `Origin` was invented. The browser guarantees correct `Origin` for cross-origin requests.
diff --git a/5-network/04-fetch-crossorigin/1-do-we-need-origin/task.md b/5-network/04-fetch-crossorigin/1-do-we-need-origin/task.md
new file mode 100644
index 000000000..6bfdc1094
--- /dev/null
+++ b/5-network/04-fetch-crossorigin/1-do-we-need-origin/task.md
@@ -0,0 +1,28 @@
+importance: 5
+
+---
+
+# Why do we need Origin?
+
+As you probably know, there's HTTP-header `Referer`, that usually contains an url of the page which initiated a network request.
+
+For instance, when fetching `http://google.com` from `http://javascript.info/some/url`, the headers look like this:
+
+```
+Accept: */*
+Accept-Charset: utf-8
+Accept-Encoding: gzip,deflate,sdch
+Connection: keep-alive
+Host: google.com
+*!*
+Origin: http://javascript.info
+Referer: http://javascript.info/some/url
+*/!*
+```
+
+As you can see, both `Referer` and `Origin` are present.
+
+The questions:
+
+1. Why `Origin` is needed, if `Referer` has even more information?
+2. If it possible that there's no `Referer` or `Origin`, or it's incorrect?
diff --git a/5-network/04-fetch-crossorigin/article.md b/5-network/04-fetch-crossorigin/article.md
new file mode 100644
index 000000000..e1b669e0e
--- /dev/null
+++ b/5-network/04-fetch-crossorigin/article.md
@@ -0,0 +1,370 @@
+# Fetch: Cross-Origin Requests
+
+If we make a `fetch` from an arbitrary web-site, that will probably fail.
+
+The core concept here is *origin* -- a domain/port/protocol triplet.
+
+Cross-origin requests -- those sent to another domain (even a subdomain) or protocol or port -- require special headers from the remote side. That policy is called "CORS": Cross-Origin Resource Sharing.
+
+For instance, let's try fetching `http://example.com`:
+
+```js run async
+try {
+  await fetch('http://example.com');
+} catch(err) {
+  alert(err); // Failed to fetch
+}
+```
+
+Fetch fails, as expected.
+
+## Why?
+
+Because cross-origin restrictions protect the internet from evil hackers.
+
+Seriously. Let's make a very brief historical digression.
+
+For many years JavaScript did not have any special methods to perform network requests.
+
+**A script from one site could not access the content of another site.**
+
+That simple, yet powerful rule was a foundation of the internet security. E.g. a script from the page `hacker.com` could not access user's mailbox at `gmail.com`. People felt safe.
+
+But web developers demanded more power. A variety of tricks were invented to work around it.
+
+One way to communicate with another server was to submit a `<form>` there. People submitted it into `<iframe>`, just to stay on the current page, like this:
+
+```html
+<!-- form target -->
+<iframe name="iframe"></iframe>
+
+<!-- a form could be dynamically generated and submited by JavaScript -->
+<form target="iframe" method="POST" action="http://another.com/…">
+  ...
+</form>
+
+```
+
+- So, it was possible to make a GET/POST request to another site, even without networking methods.
+- But as it's forbidden to access the content of an `<iframe>` from another site, it wasn't possible to read the response.
+
+So, `<form>` allowed to submit the data anywhere, but the response content was unaccessible.
+
+Another trick was to use a `<script src="http://another.com/…">` tag. A script could have any `src`, from any domain. But again -- it was impossible to access the raw content of such script.
+
+If `another.com` intended to expose data for this kind of access, then a so-called "JSONP (JSON with padding)" protocol was used.
+
+Here's the flow:
+
+1. First, in advance, we declare a global function to accept the data, e.g. `gotWeather`.
+2. Then we make a `<script>` and pass its name as the `callback` query parameter, e.g. `src="http://another.com/weather.json?callback=gotWeather"`.
+3. The remote server dynamically generates a response that wraps the data into `gotWeather(...)` call.  
+4. As the script executes, `gotWeather` runs, and, as it's our function, we have the data.
+
+Here's an example of the code to receive the data in JSONP:
+
+```js run
+// 1. Declare the function to process the data
+function gotWeather({ temperature, humidity }) {
+  alert(`temperature: ${temperature}, humidity: ${humidity}`);
+}
+
+// 2. Pass its name as the ?callback parameter for the script
+let script = document.createElement('script');
+script.src = `https://cors.javascript.info/article/fetch-crossorigin/demo/script?callback=gotWeather`;
+document.body.append(script);
+
+// 3. The expected answer from the server looks like this:
+/*
+gotWeather({
+  temperature: 25,
+  humidity: 78
+});
+*/
+```
+
+
+That works, and doesn't violate security, because both sides agreed to pass the data this way. And, when both sides agree, it's definitely not a hack. There are still services that provide such access, as it works even for very old browsers.
+
+After a while, modern network methods appeared. At first, cross-origin requests were forbidden. But as a result of long discussions, cross-domain requests were  allowed, in a way that does not add any capabilities unless explicitly allowed by the server.
+
+## Simple requests
+
+[Simple requests](http://www.w3.org/TR/cors/#terminology) must satisfy the following conditions:
+
+1. [Simple method](http://www.w3.org/TR/cors/#simple-method): GET, POST or HEAD
+2. [Simple headers](http://www.w3.org/TR/cors/#simple-header) -- only allowed:
+    - `Accept`,
+    - `Accept-Language`,
+    - `Content-Language`,
+    - `Content-Type` with the value `application/x-www-form-urlencoded`, `multipart/form-data` or `text/plain`.
+
+Any other request is considered "non-simple". For instance, a request with `PUT` method or with an `API-Key` HTTP-header does not fit the limitations.
+
+**The essential difference is that a "simple request" can be made with a `<form>` or a `<script>`, without any special methods.**
+
+So, even a very old server should be ready to accept a simple request.
+
+Contrary to that, requests with non-standard headers or e.g. method `DELETE` can't be created this way. For a long time JavaScript was unable to do such requests. So an old server may assume that such requests come from a privileged source, "because a webpage is unable to send them".
+
+When we try to make a non-simple request, the browser sends a special "preflight" request that asks the server -- does it agree to accept such cross-origin requests, or not?
+
+And, unless the server explicitly confirms that with headers, a non-simple request is not sent.
+
+Now we'll go into details. All of them serve a single purpose -- to ensure that new cross-origin capabilities are only accessible with an explicit permission from the server.
+
+## CORS for simple requests
+
+If a request is cross-origin, the browser always adds `Origin` header to it.
+
+For instance, if we request `https://anywhere.com/request` from `https://javascript.info/page`, the headers will be like:
+
+```
+GET /request
+Host: anywhere.com
+*!*
+Origin: https://javascript.info
+*/!*
+...
+```
+
+As you can see, `Origin` contains exactly the origin (domain/protocol/port), without a path.
+
+The server can inspect the `Origin` and, if it agrees to accept such a request, adds a special header `Access-Control-Allow-Origin` to the response. That header should contain the allowed origin (in our case `https://javascript.info`), or a star `*`. Then the response is successful, otherwise an error.
+
+The browser plays the role of a trusted mediator here:
+1. It ensures that the corrent `Origin` is sent with a cross-domain request.
+2. If checks for correct `Access-Control-Allow-Origin` in the response, if it is so, then JavaScript access, otherwise forbids with an error.
+
+![](xhr-another-domain.png)
+
+Here's an example of an "accepting" response:
+```
+200 OK
+Content-Type:text/html; charset=UTF-8
+*!*
+Access-Control-Allow-Origin: https://javascript.info
+*/!*
+```
+
+## Response headers
+
+For cross-origin request, by default JavaScript may only access "simple response headers":
+
+- `Cache-Control`
+- `Content-Language`
+- `Content-Type`
+- `Expires`
+- `Last-Modified`
+- `Pragma`
+
+Any other response header is forbidden.
+
+```smart header="Please note: no `Content-Length`"
+Please note: there's no `Content-Length` header in the list!
+
+So, if we're downloading something and would like to track the percentage of progress, then an additional permission is required to access that header (see below).
+```
+
+To grant JavaScript access to any other response header, the server must list it in the `Access-Control-Expose-Headers` header.
+
+For example:
+
+```
+200 OK
+Content-Type:text/html; charset=UTF-8
+Content-Length: 12345
+API-Key: 2c9de507f2c54aa1
+Access-Control-Allow-Origin: https://javascript.info
+*!*
+Access-Control-Expose-Headers: Content-Length,API-Key
+*/!*
+```
+
+With such `Access-Control-Expose-Headers` header, the script is allowed to access `Content-Length` and `API-Key` headers of the response.
+
+
+## "Non-simple" requests
+
+We can use any HTTP-method: not just `GET/POST`, but also `PATCH`, `DELETE` and others.
+
+Some time ago no one could even assume that a webpage is able to do such requests. So there may exist webservices that treat a non-standard method as a signal: "That's not a browser". They can take it into account when checking access rights.
+
+So, to avoid misunderstandings, any "non-simple" request -- that couldn't be done in the old times, the browser does not make such requests right away. Before it sends a preliminary, so-called "preflight" request, asking for permission.
+
+A preflight request uses method `OPTIONS` and has no body.
+- `Access-Control-Request-Method` header has the requested method.
+- `Access-Control-Request-Headers` header provides a comma-separated list of non-simple HTTP-headers.
+
+If the server agrees to serve the requests, then it should respond with status 200, without body.
+
+- The response header `Access-Control-Allow-Method` must have the allowed method.
+- The response header `Access-Control-Allow-Headers` must have a list of allowed headers.
+- Additionally, the header `Access-Control-Max-Age` may specify a number of seconds to cache the permissions. So the browser won't have to send a preflight for subsequent requests that satisfy given permissions.
+
+![](xhr-preflight.png)
+
+Let's see how it works step-by-step on example, for a cross-domain `PATCH` request (this method is often used to update data):
+
+```js
+let response = await fetch('https://site.com/service.json', {
+  method: 'PATCH',
+  headers: {
+    'Content-Type': 'application/json'  
+    'API-Key': 'secret'
+  }
+});
+```
+
+There are three reasons why the request is not simple (one is enough):
+- Method `PATCH`
+- `Content-Type` is not one of: `application/x-www-form-urlencoded`, `multipart/form-data`,  `text/plain`.
+- Custom `API-Key` header.
+
+### Step 1 (preflight request)
+
+The browser, on its own, sends a preflight request that looks like this:
+
+```
+OPTIONS /service.json
+Host: site.com
+Origin: https://javascript.info
+Access-Control-Request-Method: PATCH
+Access-Control-Request-Headers: Content-Type,API-Key
+```
+
+- Method: `OPTIONS`.
+- The path -- exactly the same as the main request: `/service.json`.
+- Cross-origin special headers:
+    - `Origin` -- the source origin.
+    - `Access-Control-Request-Method` -- requested method.
+    - `Access-Control-Request-Headers` -- a comma-separated list of "non-simple" headers.
+
+### Step 2 (preflight response)
+
+The server should respond with status 200 and headers:
+- `Access-Control-Allow-Method: PATCH`
+- `Access-Control-Allow-Headers: Content-Type,API-Key`.
+
+That would allow future communication, otherwise an error is triggered.
+
+If the server expects other methods and headers, makes sense to list them all at once, e.g:
+
+```
+200 OK
+Access-Control-Allow-Methods: PUT,PATCH,DELETE
+Access-Control-Allow-Headers: API-Key,Content-Type,If-Modified-Since,Cache-Control
+Access-Control-Max-Age: 86400
+```
+
+Now the browser can see that `PATCH` is in the list of allowed methods, and both headers are in the list too, so it sends out the main request.
+
+Besides, the preflight response is cached for time, specified by `Access-Control-Max-Age` header (86400 seconds, one day), so subsequent requests will not cause a preflight. Assuming that they fit the allowances, they will be sent directly.
+
+### Step 3 (actual request)
+
+When the preflight is successful, the browser now makes the real request. Here the flow is the same as for simple requests.
+
+The real request has `Origin` header (because it's cross-origin):
+
+```
+PATCH /service.json
+Host: site.com
+Content-Type: application/json
+API-Key: secret
+Origin: https://javascript.info
+```
+
+### Step 4 (actual response)
+
+The server should not forget to add `Accept-Control-Allow-Origin` to the response. A successful preflight does not relieve from that:
+
+```
+Access-Control-Allow-Origin: https://javascript.info
+```
+
+Now everything's correct. JavaScript is able to read the full response.
+
+
+## Credentials
+
+A cross-origin request by default does not bring any credentials (cookies or HTTP authentication).
+
+That's uncommon for HTTP-requests. Usually, a request to `http://site.com` is accompanied by all cookies from that domain. But cross-domain requests made by JavaScript methods are an exception.
+
+For example, `fetch('http://another.com')` does not send any cookies, even those that belong to `another.com` domain.
+
+Why?
+
+That's because a request with credentials is much more powerful than an anonymous one. If allowed, it grants JavaScript the full power to act and access sensitive information on behalf of a user.
+
+Does the server really trust pages from `Origin` that much? A request with credentials needs an additional header to pass through.
+
+To enable credentials, we need to add the option `credentials: "include"`, like this:
+
+```js
+fetch('http://another.com', {
+  credentials: "include"
+});
+```
+
+Now `fetch` sends cookies originating from `another.com` with the request.
+
+If the server wishes to accept the request with credentials, it should add a header `Access-Control-Allow-Credentials: true` to the response, in addition to `Access-Control-Allow-Origin`.
+
+For example:
+
+```
+200 OK
+Access-Control-Allow-Origin: https://javascript.info
+Access-Control-Allow-Credentials: true
+```
+
+Please note: `Access-Control-Allow-Origin` is prohibited from using a star `*` for requests with credentials. There must be exactly the origin there, like above. That's an additional safety measure, to ensure that the server really knows who it trusts.
+
+
+## Summary
+
+Networking methods split cross-origin requests into two kinds: "simple" and all the others.
+
+[Simple requests](http://www.w3.org/TR/cors/#terminology) must satisfy the following conditions:
+- Method: GET, POST or HEAD.
+- Headers -- we can set only:
+    - `Accept`
+    - `Accept-Language`
+    - `Content-Language`
+    - `Content-Type` to the value `application/x-www-form-urlencoded`, `multipart/form-data` or `text/plain`.
+
+The essential difference is that simple requests were doable since ancient times using `<form>` or `<script>` tags, while non-simple were impossible for browsers for a long time.
+
+So, practical difference is that simple requests are sent right away, with `Origin` header, but for other ones the browser makes a preliminary "preflight" request, asking for permission.
+
+**For simple requests:**
+
+- → The browser sends `Origin` header with the origin.
+- ← For requests without credentials (default), the server should set:
+    - `Access-Control-Allow-Origin` to `*` or same as `Origin`
+- ← For requests with credentials, the server should set:
+    - `Access-Control-Allow-Origin` to `Origin`
+    - `Access-Control-Allow-Credentials` to `true`
+
+Additionally, if JavaScript wants no access non-simple response headers:
+- `Cache-Control`
+- `Content-Language`
+- `Content-Type`
+- `Expires`
+- `Last-Modified`
+- `Pragma`
+
+...Then the server should list the allowed ones in `Access-Control-Expose-Headers` header.
+
+**For non-simple requests, a preliminary "preflight" request is issued before the requested one:**
+
+- → The browser sends `OPTIONS` request to the same url, with headers:
+    - `Access-Control-Request-Method` has requested method.
+    - `Access-Control-Request-Headers` lists non-simple requested headers
+- ← The server should respond with status 200 and headers:
+    - `Access-Control-Allow-Method` with a list of allowed methods,
+    - `Access-Control-Allow-Headers` with a list of allowed headers,
+    - `Access-Control-Max-Age` with a number of seconds to cache permissions.
+- Then the actual request is sent, the previous "simple" scheme is applied.
diff --git a/5-network/04-fetch-crossorigin/cors-gmail-messages.png b/5-network/04-fetch-crossorigin/cors-gmail-messages.png
new file mode 100644
index 000000000..ef5eb3243
Binary files /dev/null and b/5-network/04-fetch-crossorigin/cors-gmail-messages.png differ
diff --git a/5-network/04-fetch-crossorigin/cors-gmail-messages@2x.png b/5-network/04-fetch-crossorigin/cors-gmail-messages@2x.png
new file mode 100644
index 000000000..c9ff82d3c
Binary files /dev/null and b/5-network/04-fetch-crossorigin/cors-gmail-messages@2x.png differ
diff --git a/5-network/04-fetch-crossorigin/demo.view/index.html b/5-network/04-fetch-crossorigin/demo.view/index.html
new file mode 100644
index 000000000..7e367598c
--- /dev/null
+++ b/5-network/04-fetch-crossorigin/demo.view/index.html
@@ -0,0 +1,31 @@
+<!doctype html>
+<script>
+
+async function init() {
+	const response = await fetch('long.txt');
+	const reader = response.body.getReader();
+
+	const contentLength = +response.headers.get('Content-Length');
+	let receivedLength = 0;
+
+	while(true) {
+		const chunk = await reader.read();
+
+		if (chunk.done) {
+			console.log("done!");
+			break;
+		}
+
+		receivedLength += chunk.value.length;
+		console.log(`${receivedLength}/${contentLength} received`)
+	}
+
+	let result = await response.text();
+	console.log(result);
+	//const chunkCount = await read(reader);
+	//console.log(`Finished! Received ${chunkCount} chunks.`);
+}
+
+init();
+
+</script>
diff --git a/5-network/04-fetch-crossorigin/demo.view/server.js b/5-network/04-fetch-crossorigin/demo.view/server.js
new file mode 100644
index 000000000..588ca0653
--- /dev/null
+++ b/5-network/04-fetch-crossorigin/demo.view/server.js
@@ -0,0 +1,31 @@
+const Koa = require('koa');
+const app = new Koa();
+
+const Router = require('koa-router');
+
+let router = new Router();
+
+router.get('/script', async (ctx) => {
+  let callback = ctx.query.callback;
+
+  if (!callback) {
+    ctx.throw(400, 'Callback required!');
+  }
+
+  ctx.type = 'application/javascript';
+  ctx.body = `${callback}({
+    temperature: 25,
+    humidity: 78
+  })`;
+});
+
+app
+  .use(router.routes())
+  .use(router.allowedMethods());
+
+
+if (!module.parent) {
+  http.createServer(app.callback()).listen(8080);
+} else {
+  exports.accept = app.callback();
+}
diff --git a/5-network/04-fetch-crossorigin/xhr-another-domain.png b/5-network/04-fetch-crossorigin/xhr-another-domain.png
new file mode 100644
index 000000000..0be23b1eb
Binary files /dev/null and b/5-network/04-fetch-crossorigin/xhr-another-domain.png differ
diff --git a/5-network/04-fetch-crossorigin/xhr-another-domain@2x.png b/5-network/04-fetch-crossorigin/xhr-another-domain@2x.png
new file mode 100644
index 000000000..030606b22
Binary files /dev/null and b/5-network/04-fetch-crossorigin/xhr-another-domain@2x.png differ
diff --git a/5-network/04-fetch-crossorigin/xhr-preflight.png b/5-network/04-fetch-crossorigin/xhr-preflight.png
new file mode 100644
index 000000000..a11a70926
Binary files /dev/null and b/5-network/04-fetch-crossorigin/xhr-preflight.png differ
diff --git a/5-network/04-fetch-crossorigin/xhr-preflight@2x.png b/5-network/04-fetch-crossorigin/xhr-preflight@2x.png
new file mode 100644
index 000000000..1333ec374
Binary files /dev/null and b/5-network/04-fetch-crossorigin/xhr-preflight@2x.png differ
diff --git a/5-network/05-fetch-api/article.md b/5-network/05-fetch-api/article.md
new file mode 100644
index 000000000..7b0330f26
--- /dev/null
+++ b/5-network/05-fetch-api/article.md
@@ -0,0 +1,190 @@
+
+# Fetch API
+
+So far, we know quite a bit about fetch.
+
+Now let's see the rest of API, to cover all its abilities.
+
+Here's the full list of all possible fetch options with their default values (alternatives in comments):
+
+```js
+let promise = fetch(url, {
+  method: "GET", // POST, PUT, DELETE, etc.
+  headers: {
+    "Content-Type": "text/plain;charset=UTF-8" // for a string body, depends on body
+  },
+  body: undefined // string, FormData, Blob, BufferSource, or URLSearchParams
+  referrer: "about:client", // "" for no-referrer, or an url from the current origin
+  referrerPolicy: "no-referrer-when-downgrade", // no-referrer, origin, same-origin...
+  mode: "cors", // same-origin, no-cors
+  credentials: "same-origin", // omit, include
+  cache: "default", // no-store, reload, no-cache, force-cache, or only-if-cached
+  redirect: "follow", // manual, error
+  integrity: "", // a hash, like "sha256-abcdef1234567890"
+  keepalive: false, // true
+  signal: undefined, // AbortController to abort request
+  window: window // null
+});
+```
+
+An impressive list, right?
+
+We fully covered `method`, `headers` and `body` in the chapter <info:fetch-basics>.
+
+The `signal` option is covered in <info:fetch-abort>.
+
+Now let's explore the rest of options.
+
+## referrer, referrerPolicy
+
+These options govern how `fetch` sets HTTP `Referer` header.
+
+That header contains the url of the page that made the request. In most scenarios, it plays a very minor informational role, but sometimes, for security purposes, it makes sense to remove or modify it.
+.
+
+**The `referrer` option allows to set any `Referer` within the current origin) or disable it.**
+
+To send no referer, set an empty string:
+```js
+fetch('/page', {
+*!*
+  referrer: "" // no Referer header
+*/!*
+});
+```
+
+To set another url within the current origin:
+
+```js
+fetch('/page', {
+  // assuming we're on https://javascript.info
+  // we can set any Referer header, but only within the current origin
+*!*
+  referrer: "https://javascript.info/anotherpage"
+*/!*
+});
+```
+
+**The `referrerPolicy` option sets general rules for `Referer`.**
+
+Possible values are described in the [Referrer Policy specification](https://w3c.github.io/webappsec-referrer-policy/):
+
+- **`"no-referrer-when-downgrade"`** -- default value: `Referer` is sent always, unless we send a request from HTTPS to HTTP (to less secure protocol).
+- **`"no-referrer"`** -- never send `Referer`.
+- **`"origin"`** -- only send the origin in `Referer`, not the full page URL, e.g. `http://site.com` instead of `http://site.com/path`.
+- **`"origin-when-cross-origin"`** -- send full referrer to the same origin, but only the origin part for cross-origin requests.
+- **`"same-origin"`** -- send full referrer to the same origin, but no referer for for cross-origin requests.
+- **`"strict-origin"`** -- send only origin, don't send referrer for HTTPS→HTTP requests.
+- **`"strict-origin-when-cross-origin"`** -- for same-origin send full referrer, for cross-origin send only origin, unless it's HTTPS→HTTP request, then send nothing.
+- **`"unsafe-url"`** -- always send full url in `Referer`.
+
+Let's say we have an admin zone with URL structure that shouldn't be visible from outside.
+
+If we send a cross-origin `fetch`, then by default it sends the `Referer` header with the full url of our page (except when we request from HTTPS to HTTP, then no `Referer`).
+
+E.g. `Referer: https://javascript.info/admin/secret/paths`.
+
+If we'd like to totally hide the referrer:
+
+```js
+fetch('https://another.com/page', {
+  referrerPolicy: "no-referrer" // no Referer, same effect as referrer: ""
+});
+```
+
+Otherwise, if we'd like the remote side to see where the request comes from, we can send only the "origin" part of the url:
+
+```js
+fetch('https://another.com/page', {
+  referrerPolicy: "strict-origin" // Referer: https://javascript.info
+});
+```
+
+## mode
+
+The `mode` option serves as a safe-guard that prevents cross-origin requests:
+
+- **`"cors"`** -- the default, cross-origin requests are allowed, as described in <info:fetch-crossorigin>,
+- **`"same-origin"`** -- cross-origin requests are forbidden,
+- **`"no-cors"`** -- only simple cross-origin requests are allowed.
+
+That may be useful in contexts when the fetch url comes from 3rd-party, and we want a "power off switch" to limit cross-origin capabilities.
+
+## credentials
+
+The `credentials` option specifies whether `fetch` should send cookies and HTTP-Authorization headers with the request.
+
+- **`"same-origin"`** -- the default, don't send for cross-origin requests,
+- **`"include"`** -- always send, requires `Accept-Control-Allow-Credentials` from cross-origin server,
+- **`"omit"`** -- never send, even for same-origin requests.
+
+## cache
+
+By default, `fetch` requests make use of standard HTTP-caching. That is, it honors `Expires`, `Cache-Control` headers, sends `If-Modified-Since`, and so on. Just like regular HTTP-requests do.
+
+The `cache` options allows to ignore HTTP-cache or fine-tune its usage:
+
+- **`"default"`** -- `fetch` uses standard HTTP-cache rules and headers;
+- **`"no-store"`** -- totally ignore HTTP-cache, this mode becomes the default if we set a header `If-Modified-Since`, `If-None-Match`, `If-Unmodified-Since`, `If-Match`, or `If-Range`;
+- **`"reload"`** -- don't take the result from HTTP-cache (if any), but populate cache with the response (if response headers allow);
+- **`"no-cache"`** -- create a conditional request if there is a cached response, and a normal request otherwise. Populate HTTP-cache with the response;
+- **`"force-cache"`** -- use a response from HTTP-cache, even if it's stale. If there's no response in HTTP-cache, make a regular HTTP-request, behave normally;
+- **`"only-if-cached"`** -- use a response from HTTP-cache, even if it's stale. If there's no response in HTTP-cache, then error. Only works when `mode` is `"same-origin"`.
+
+## redirect
+
+Normally, `fetch` transparently follows HTTP-redirects, like 301, 302 etc.
+
+The `redirect` option allows to change that:
+
+- **`"follow"`** -- the default, follow HTTP-redirects,
+- **`"error"`** -- error in case of HTTP-redirect,
+- **`"manual"`** -- don't follow HTTP-redirect, but `response.url` will be the new URL, and `response.redirected` will be `true`, so that we can perform the redirect manually to the new URL (if needed).
+
+## integrity
+
+The `integrity` option allows to check if the response matches the known-ahead checksum.
+
+As described in the [specification](https://w3c.github.io/webappsec-subresource-integrity/), supported hash-functions are SHA-256, SHA-384, and SHA-512, there might be others depending on a browser.
+
+For example, we're downloading a file, and we know that it's SHA-256 checksum is "abc" (a real checksum is longer, of course).
+
+We can put it in the `integrity` option, like this:
+
+```js
+fetch('http://site.com/file', {
+  integrity: 'sha256-abd'
+});
+```
+
+Then `fetch` will calculate SHA-256 on its own and compare it with our string. In case of a mismatch, an error is triggered.
+
+## keepalive
+
+The `keepalive` option indicates that the request may outlive the page.
+
+For example, we gather statistics about how the current visitor uses our page (mouse clicks,  page fragments he views), to improve user experience.
+
+When the visitor leaves our page -- we'd like to save it on our server.
+
+We can use `window.onunload` for that:
+
+```js run
+window.onunload = function() {
+  fetch('/analytics', {
+    method: 'POST',
+    body: "statistics",
+*!*
+    keepalive: true
+*/!*
+  });
+};
+```
+
+Normally, when a document is unloaded, all associated network requests are aborted. But `keepalive` option tells the browser to perform the request in background, even after it leaves the page. So it's essential for our request to succeed.
+
+- We can't send megabytes: the body limit for keepalive requests is 64kb.
+    - If we gather more data, we can send it out regularly, then there won't be a lot for the "onunload" request.
+    - The limit is for all currently ongoing requests. So we cheat it by creating 100 requests, each 64kb.
+- We don't get the server response if the request is made `onunload`, because the document is already unloaded at that time.
+    - Usually, the server sends empty response to such requests, so it's not a problem.
diff --git a/5-network/05-fetch-api/logo-fetch.svg b/5-network/05-fetch-api/logo-fetch.svg
new file mode 100644
index 000000000..5a58b209b
--- /dev/null
+++ b/5-network/05-fetch-api/logo-fetch.svg
@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+<circle cx="50" cy="50" r="45" fill="#fff" stroke="#3c790a" stroke-width="10"/>
+<path d="m34,55a60,60,0,0,0,20,-20a6,10,0,0,1,13,-1a10,6,0,0,1,-1,13a60,60,0,0,0,-20,20a6,10,0,0,1,-13,1a10,6,0,0,1,1,-13" fill="#3c790a"/>
+</svg>
diff --git a/5-network/05-fetch-api/post.view/index.html b/5-network/05-fetch-api/post.view/index.html
new file mode 100644
index 000000000..ba7f76065
--- /dev/null
+++ b/5-network/05-fetch-api/post.view/index.html
@@ -0,0 +1,36 @@
+<!doctype html>
+<script>
+(async () {
+	
+	const response = await fetch('long.txt');
+	const reader = response.body.getReader();
+
+	const contentLength = +response.headers.get('Content-Length');
+	let receivedLength = 0;
+	let chunks = [];
+	while(true) {
+		const chunk = await reader.read();
+
+		if (chunk.done) {
+			console.log("done!");
+			break;
+		}
+
+		chunks.push(chunk.value);
+		receivedLength += chunk.value.length;
+		console.log(`${receivedLength}/${contentLength} received`)
+	}
+
+
+	let chunksMerged = new Uint8Array(receivedLength);
+	let length = 0;
+	for(let chunk of chunks) {
+		chunksMerged.set(chunk, length);
+		length += chunk.length;
+	}
+
+	let result = new TextDecoder("utf-8").decode(chunksMerged);
+	console.log(result);
+})();
+
+</script>
diff --git a/5-network/05-fetch-api/post.view/server.js b/5-network/05-fetch-api/post.view/server.js
new file mode 100644
index 000000000..5e182a2ba
--- /dev/null
+++ b/5-network/05-fetch-api/post.view/server.js
@@ -0,0 +1,55 @@
+let http = require('http');
+let url = require('url');
+let querystring = require('querystring');
+let static = require('node-static');
+let file = new static.Server('.', {
+  cache: 0
+});
+
+
+function accept(req, res) {
+
+  if (req.method == 'POST') {
+    let chunks = [];
+    let length = 0;
+
+    req.on('data', function (data) {
+      chunks.push(data);
+      length += data.length;
+
+      // Too much POST data, kill the connection!
+      if (length > 1e6) {
+        request.connection.destroy();
+      }
+    });
+
+    req.on('end', function() {
+      // let post = JSON.parse(chunks.join(''));
+
+      if (req.url == '/user') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ message: 'User saved' }));
+      } else if (req.url == '/image') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ message: "Image saved", imageSize: length }));
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+
+
+  } else {
+    file.serve(req, res);
+  }
+
+}
+
+
+// ------ запустить сервер -------
+
+if (!module.parent) {
+  http.createServer(accept).listen(8080);
+} else {
+  exports.accept = accept;
+}
diff --git a/5-network/06-url/article.md b/5-network/06-url/article.md
new file mode 100644
index 000000000..61c4f9414
--- /dev/null
+++ b/5-network/06-url/article.md
@@ -0,0 +1,96 @@
+
+# URL objects
+
+The built-in [URL](https://url.spec.whatwg.org/#api) class provides a convenient interface for creating and parsing URLs.
+
+We don't have to use it at all. There are no networking methods that require exactly an `URL` object, strings are good enough. But sometimes it can be really helpful.
+
+## Creating an URL
+
+The syntax to create a new URL object:
+
+```js
+new URL(url, [base])
+```
+
+- **`url`** -- the text url
+- **`base`** -- an optional base for the `url`
+
+The `URL` object immediately allows us to access its components, so it's a nice way to parse the url, e.g.:
+
+```js run
+let url = new URL('https://javascript.info/url');
+
+alert(url.protocol); // https:
+alert(url.host);     // javascript.info
+alert(url.pathname); // /url
+```
+
+Here's the cheatsheet:
+
+![](url-object.png)
+
+- `href` is the full url, same as `url.toString()`
+- `protocol` ends with the colon character `:`
+- `search` starts with the question mark `?`
+- `hash` ends with the hash character `#`
+- there are also `user` and `password` properties if HTTP authentication is present.
+
+We can also use `URL` to create relative urls, using the second argument:
+
+```js run
+let url = new URL('profile/admin', 'https://javascript.info');
+
+alert(url); // https://javascript.info/profile/admin
+
+url = new URL('tester', url); // go to 'tester' relative to current url path
+
+alert(url); // https://javascript.info/profile/tester
+```
+
+```smart header="We can use `URL` everywhere instead of a string"
+We can use an `URL` object in `fetch` or `XMLHttpRequest`, almost everywhere where a string url is expected.
+
+In the vast majority of methods it's automatically converted to a string.
+```
+
+## SearchParams
+
+Let's say we want to create an url with given search params, for instance, `https://google.com/search?query=value`.
+
+They must be correctly encoded.
+
+In very old browsers, before `URL` apparead, we'd use built-in functions `encodeURIComponent/decodeURIComponent`.
+
+Now, there's no need: `url.searchParams` is an object of type [URLSearchParams](https://url.spec.whatwg.org/#urlsearchparams).
+
+It provides convenient methods for search parameters:
+
+- **`append(name, value)`** -- add the parameter,
+- **`delete(name)`** -- remove the parameter,
+- **`get(name)`** -- get the parameter,
+- **`getAll(name)`** -- get all parameters with that name (if many, e.g. `?user=John&user=Pete`),
+- **`has(name)`** -- check for the existance of the parameter,
+- **`set(name, value)`** -- set/replace the parameter,
+- **`sort()`** -- sort parameters by name, rarely needed,
+- ...and also iterable, similar to `Map`.
+
+So, `URL` object also provides an easy way to operate on url parameters.
+
+For example:
+
+```js run
+let url = new URL('https://google.com/search');
+url.searchParams.set('query', 'test me!');
+
+alert(url); // https://google.com/search?query=test+me%21
+
+url.searchParams.set('tbs', 'qdr:y'); // add param for date range: past year
+
+alert(url); // https://google.com/search?query=test+me%21&tbs=qdr%3Ay
+
+// iterate over search parameters (decoded)
+for(let [name, value] of url.searchParams) {
+  alert(`${name}=${value}`); // query=test me!, then tbs=qdr:y
+}
+```
diff --git a/5-network/06-url/url-object.png b/5-network/06-url/url-object.png
new file mode 100644
index 000000000..7e549d28f
Binary files /dev/null and b/5-network/06-url/url-object.png differ
diff --git a/5-network/06-url/url-object@2x.png b/5-network/06-url/url-object@2x.png
new file mode 100644
index 000000000..cfbe21de0
Binary files /dev/null and b/5-network/06-url/url-object@2x.png differ
diff --git a/5-network/07-xmlhttprequest/article.md b/5-network/07-xmlhttprequest/article.md
new file mode 100644
index 000000000..bda4bd1b7
--- /dev/null
+++ b/5-network/07-xmlhttprequest/article.md
@@ -0,0 +1,507 @@
+# XMLHttpRequest
+
+`XMLHttpRequest` is a built-in browser object that allows to make HTTP requests in JavaScript.
+
+Despite of having the word "XML" in its name, it can operate on any data, not only in XML format. We can upload/download files, track progress and much more.
+
+Right now, there's another, more modern method `fetch`, that somewhat deprecates `XMLHttpRequest`.
+
+In modern web-development `XMLHttpRequest` may be used for three reasons:
+
+1. Historical reasons: we need to support existing scripts with `XMLHttpRequest`.
+2. We need to support old browsers, and don't want polyfills (e.g. to keep scripts tiny).
+3. We need something that `fetch` can't do yet, e.g. to track upload progress.
+
+Does that sound familiar? If yes, then all right, go on with `XMLHttpRequest`. Otherwise, please head on to fetch (coming soon).
+
+## Basic flow
+
+XMLHttpRequest has two modes of operation: synchronous and asynchronous.
+
+Let's see the asynchronous first, as it's used in the majority of cases.
+
+To do the request, we need 3 steps:
+
+1. Create `XMLHttpRequest`.
+    ```js
+    let xhr = new XMLHttpRequest(); // no arguments
+    ```
+
+2. Initialize it.
+    ```js
+    xhr.open(method, URL, [async, user, password])
+    ```
+
+    This method is usually called first after `new XMLHttpRequest`. It specifies the main parameters of the request:
+
+    - `method` -- HTTP-method. Usually `"GET"` or `"POST"`.
+    - `URL` -- the URL to request.
+    - `async` -- if explicitly set to `false`, then the request is synchronous, we'll cover that a bit later.
+    - `user`, `password` -- login and password for basic HTTP auth (if required).
+
+    Please note that `open` call, contrary to its name, does not open the connection. It only configures the request, but the network activity only starts with the call of `send`.
+
+3. Send it out.
+
+    ```js
+    xhr.send([body])
+    ```
+
+    This method opens the connection and sends the request to server. The optional `body` parameter contains the request body.
+
+    Some request methods like `GET` do not have a body. And some of them like `POST` use `body` to send the data to the server. We'll see examples later.
+
+4. Listen to events for response.
+
+    These three are the most widely used:
+    - `load` -- when the result is ready, that includes HTTP errors like 404.
+    - `error` -- when the request couldn't be made, e.g. network down or invalid URL.
+    - `progress` -- triggers periodically during the download, reports how much downloaded.
+
+    ```js
+    xhr.onload = function() {
+      alert(`Loaded: ${xhr.status} ${xhr.response}`);
+    };
+
+    xhr.onerror = function() { // only triggers if the request couldn't be made at all
+      alert(`Network Error`);
+    };
+
+    xhr.onprogress = function(event) { // triggers periodically
+      // event.loaded - how many bytes downloaded
+      // event.lengthComputable = true if the server sent Content-Length header
+      // event.total - total number of bytes (if lengthComputable)
+      alert(`Received ${event.loaded} of ${event.total}`);
+    };
+    ```
+
+Here's a full example. The code below loads the URL at `/article/xmlhttprequest/example/load` from the server and prints the progress:
+
+```js run
+// 1. Create a new XMLHttpRequest object
+let xhr = new XMLHttpRequest();
+
+// 2. Configure it: GET-request for the URL /article/.../load
+xhr.open('GET', '/article/xmlhttprequest/example/load');
+
+// 3. Send the request over the network
+xhr.send();
+
+// 4. This will be called after the response is received
+xhr.onload = function() {
+  if (xhr.status != 200) { // analyze HTTP status of the response
+    alert(`Error ${xhr.status}: ${xhr.statusText}`); // e.g. 404: Not Found
+  } else { // show the result
+    alert(`Done, got ${xhr.response.length} bytes`); // responseText is the server
+  }
+};
+
+xhr.onprogress = function(event) {
+  if (event.lengthComputable) {
+    alert(`Received ${event.loaded} of ${event.total} bytes`);
+  } else {
+    alert(`Received ${event.loaded} bytes`); // no Content-Length
+  }
+
+};
+
+xhr.onerror = function() {
+  alert("Request failed");
+};
+```
+
+Once the server has responded, we can receive the result in the following properties of the request object:
+
+`status`
+: HTTP status code (a number): `200`, `404`, `403` and so on, can be `0` in case of a non-HTTP failure.
+
+`statusText`
+: HTTP status message (a string): usually `OK` for `200`, `Not Found` for `404`, `Forbidden` for `403` and so on.
+
+`response` (old scripts may use `responseText`)
+: The server response.
+
+If we changed our mind, we can terminate the request at any time. The call to `xhr.abort()` does that:
+
+```js
+xhr.abort(); // terminate the request
+```
+
+That triggers `abort` event.
+
+We can also specify a timeout using the corresponding property:
+
+```js
+xhr.timeout = 10000; // timeout in ms, 10 seconds
+```
+
+If the request does not succeed within the given time, it gets canceled and `timeout` event triggers.
+
+## Response Type
+
+We can use `xhr.responseType` property to set the response format:
+
+- `""` (default) -- get as string,
+- `"text"` -- get as string,
+- `"arraybuffer"` -- get as `ArrayBuffer` (for binary data, see chapter <info:arraybuffer-and-views>),
+- `"blob"` -- get as `Blob` (for binary data, see chapter <info:blob>),
+- `"document"` -- get as XML document (can use XPath and other XML methods),
+- `"json"` -- get as JSON (parsed automatically).
+
+For example, let's get the response as JSON:
+
+```js run
+let xhr = new XMLHttpRequest();
+
+xhr.open('GET', '/article/xmlhttprequest/example/json');
+
+*!*
+xhr.responseType = 'json';
+*/!*
+
+xhr.send();
+
+// the response is {"message": "Hello, world!"}
+xhr.onload = function() {
+  let responseObj = xhr.response;
+  alert(responseObj.message); // Hello, world!
+};
+```
+
+```smart
+In the old scripts you may also find `xhr.responseText` and even `xhr.responseXML` properties.
+
+They exist for historical reasons, to get either a string or XML document. Nowadays, we should set the format in `xhr.responseType` and get `xhr.response` as demonstrated above.
+```
+
+## Ready states
+
+`XMLHttpRequest` changes between states as it progresses. The current state is accessible as  `xhr.readyState`.
+
+All states, as in [the specification](https://xhr.spec.whatwg.org/#states):
+
+```js
+UNSENT = 0; // initial state
+OPENED = 1; // open called
+HEADERS_RECEIVED = 2; // response headers received
+LOADING = 3; // response is loading (a data packed is received)
+DONE = 4; // request complete
+```
+
+An `XMLHttpRequest` object travels them in the order `0` -> `1` -> `2` -> `3` -> ... -> `3` -> `4`. State `3` repeats every time a data packet is received over the network.
+
+We can track them using `readystatechange` event:
+
+```js
+xhr.onreadystatechange = function() {
+  if (xhr.readyState == 3) {
+    // loading
+  }
+  if (xhr.readyState == 4) {
+    // request finished
+  }
+};
+```
+
+You can find `readystatechange` listeners in really old code, for historical reasons.
+
+Nowadays, `load/error/progress` handlers deprecate it.
+
+## Synchronous requests
+
+If in the `open` method the third parameter `async` is set to `false`, the request is made synchronously.
+
+In other words, JavaScript execution pauses at `send()` and resumes when the response is received. Somewhat like `alert` or `prompt` commands.
+
+Here's the rewritten example, the 3rd parameter of `open` is `false`:
+
+```js
+let xhr = new XMLHttpRequest();
+
+xhr.open('GET', '/article/xmlhttprequest/hello.txt', *!*false*/!*);
+
+try {
+  xhr.send();
+  if (xhr.status != 200) {
+    alert(`Error ${xhr.status}: ${xhr.statusText}`);
+  } else {
+    alert(xhr.response);
+  }
+} catch(err) { // instead of onerror
+  alert("Request failed");
+};
+```
+
+It might look good, but synchronous calls are used rarely, because they block in-page JavaScript till the loading is complete. In some browsers it becomes impossible to scroll. If a synchronous call takes too much time, the browser may suggest to close the "hanging" webpage.
+
+Many advanced capabilities of `XMLHttpRequest`, like requesting from another domain or specifying a timeout, are unavailable for synchronous requests. Also, as you can see, no progress indication.
+
+Because of all that, synchronous requests are used very sparingly, almost never. We won't talk about them any more.
+
+## HTTP-headers
+
+`XMLHttpRequest` allows both to send custom headers and read headers from the response.
+
+There are 3 methods for HTTP-headers:
+
+`setRequestHeader(name, value)`
+: Sets the request header with the given `name` and `value`.
+
+    For instance:
+
+    ```js
+    xhr.setRequestHeader('Content-Type', 'application/json');
+    ```
+
+    ```warn header="Headers limitations"
+    Several headers are managed exclusively by the browser, e.g. `Referer` and `Host`.
+    The full list is [in the specification](http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader-method).
+
+    XMLHttpRequest is not allowed to change them, for the sake of user safety and correctness of the request.
+    ```
+
+    ````warn header="Can't remove a header"
+    Another peciliarity of `XMLHttpRequest` is that one can't undo `setRequestHeader`.
+
+    Once the header is set, it's set. Additional calls add information to the header, don't overwrite it.
+
+    For instance:
+
+    ```js
+    xhr.setRequestHeader('X-Auth', '123');
+    xhr.setRequestHeader('X-Auth', '456');
+
+    // the header will be:
+    // X-Auth: 123, 456
+    ```
+    ````
+
+`getResponseHeader(name)`
+: Gets the response header with the given `name` (except `Set-Cookie` and `Set-Cookie2`).
+
+    For instance:
+
+    ```js
+    xhr.getResponseHeader('Content-Type')
+    ```
+
+`getAllResponseHeaders()`
+: Returns all response headers, except `Set-Cookie` and `Set-Cookie2`.
+
+    Headers are returned as a single line, e.g.:
+
+    ```
+    Cache-Control: max-age=31536000
+    Content-Length: 4260
+    Content-Type: image/png
+    Date: Sat, 08 Sep 2012 16:53:16 GMT
+    ```
+
+    The line break between headers is always `"\r\n"` (doesn't depend on OS), so we can easily split it into individual headers. The separator between the name and the value is always a colon followed by a space `": "`. That's fixed in the specification.
+
+    So, if we want to get an object with name/value pairs, we need to throw in a bit JS.
+
+    Like this (assuming that if two headers have the same name, then the latter one overwrites the former one):
+
+    ```js
+    let headers = xhr
+      .getAllResponseHeaders()
+      .split('\r\n')
+      .reduce((result, current) => {
+        let [name, value] = current.split(': ');
+        result[name] = value;
+        return result;
+      }, {});
+    ```
+
+## POST, FormData
+
+To make a POST request, we can use the built-in [FormData](https://developer.mozilla.org/en-US/docs/Web/API/FormData) object.
+
+The syntax:
+
+```js
+let formData = new FormData([form]); // creates an object, optionally fill from <form>
+formData.append(name, value); // appends a field
+```
+
+Create it, optionally from a form, `append` more fields if needed, and then:
+
+1. `xhr.open('POST', ...)` – use `POST` method.
+2. `xhr.send(formData)` to submit the form to the server.
+
+For instance:
+
+```html run
+<form name="person">
+  <input name="name" value="John">
+  <input name="surname" value="Smith">
+</form>
+
+<script>
+  // pre-fill FormData from the form
+  let formData = new FormData(document.forms.person);
+
+  // add one more field
+  formData.append("middle", "Lee");
+
+  // send it out
+  let xhr = new XMLHttpRequest();
+  xhr.open("POST", "/article/xmlhttprequest/post/user");
+  xhr.send(formData);
+
+</script>
+```
+
+The form is sent with `multipart/form-data` encoding.
+
+Or, if we like JSON more, then `JSON.stringify` and send as a string.
+
+Just don't forget to set the header `Content-Type: application/json`, many server-side frameworks automatically decode JSON with it:
+
+```js
+let xhr = new XMLHttpRequest();
+
+let json = JSON.stringify({
+  name: "John",
+  surname: "Smith"
+});
+
+xhr.open("POST", '/submit')
+xhr.setRequestHeader('Content-type', 'application/json; charset=utf-8');
+
+xhr.send(json);
+```
+
+The `.send(body)` method is pretty omnivore. It can send almost everything, including Blob and BufferSource objects.
+
+## Upload progress
+
+The `progress` event only works on the downloading stage.
+
+That is: if we `POST` something, `XMLHttpRequest` first uploads our data, then downloads the response.
+
+If we're uploading something big, then we're surely more interested in tracking the upload progress. But `progress` event doesn't help here.
+
+There's another object `xhr.upload`, without methods, exclusively for upload events.
+
+Here's the list:
+
+- `loadstart` -- upload started.
+- `progress` -- triggers periodically during the upload.
+- `abort` -- upload aborted.
+- `error` -- non-HTTP error.
+- `load` -- upload finished successfully.
+- `timeout` -- upload timed out (if `timeout` property is set).
+- `loadend` -- upload finished with either success or error.
+
+Example of handlers:
+
+```js
+xhr.upload.onprogress = function(event) {
+  alert(`Uploaded ${event.loaded} of ${event.total} bytes`);
+};
+
+xhr.upload.onload = function() {
+  alert(`Upload finished successfully.`);
+};
+
+xhr.upload.onerror = function() {
+  alert(`Error during the upload: ${xhr.status}`);
+};
+```
+
+Here's a real-life example: file upload with progress indication:
+
+```html run
+<input type="file" onchange="upload(this.files[0])">
+
+<script>
+function upload(file) {
+  let xhr = new XMLHttpRequest();
+
+  // track upload progress
+*!*
+  xhr.upload.onprogress = function(event) {
+    console.log(`Uploaded ${event.loaded} of ${event.total}`);
+  };
+*/!*
+
+  // track completion: both successful or not
+  xhr.onloadend = function() {
+    if (xhr.status == 200) {
+      console.log("success");
+    } else {
+      console.log("error " + this.status);
+    }
+  };
+
+  xhr.open("POST", "/article/xmlhttprequest/post/upload");
+  xhr.send(file);
+}
+</script>
+```
+
+## Cross-origin requests
+
+`XMLHttpRequest` can make cross-domain requests, using the same CORS policy as [fetch](info:fetch-crossorigin).
+
+Just like `fetch`, it doesn't send cookies and HTTP-authorization to another origin by default. To enable them, set `xhr.withCredentials` to `true`:
+
+```js
+let xhr = new XMLHttpRequest();
+*!*
+xhr.withCredentials = true;
+*/!*
+
+xhr.open('POST', 'http://anywhere.com/request');
+...
+```
+
+
+## Summary
+
+Typical code of the GET-request with `XMLHttpRequest`:
+
+```js
+let xhr = new XMLHttpRequest();
+
+xhr.open('GET', '/my/url');
+
+xhr.send(); // for POST, can send a string or FormData
+
+xhr.onload = function() {
+  if (xhr.status != 200) { // HTTP error?
+    // handle error
+    alert( 'Error: ' + xhr.status);
+    return;
+  }
+
+  // get the response from xhr.response
+};
+
+xhr.onprogress = function(event) {
+  // report progress
+  alert(`Loaded ${event.loaded} of ${event.total}`);
+};
+
+xhr.onerror = function() {
+  // handle non-HTTP error (e.g. network down)
+};
+```
+
+There are actually more events, the [modern specification](http://www.w3.org/TR/XMLHttpRequest/#events) lists them (in the lifecycle order):
+
+- `loadstart` -- the request has started.
+- `progress` -- a data packet of the response has arrived, the whole response body at the moment is in `responseText`.
+- `abort` -- the request was canceled by the call `xhr.abort()`.
+- `error` -- connection error has occured, e.g. wrong domain name. Doesn't happen for HTTP-errors like 404.
+- `load` -- the request has finished successfully.
+- `timeout` -- the request was canceled due to timeout (only happens if it was set).
+- `loadend` -- the request has finished (succeffully or not).
+
+The most used events are load completion (`load`), load failure (`error`), and also `progress` to track the progress.
+
+We've already seen another event: `readystatechange`. Historically, it appeared long ago, before the specification settled. Nowadays, there's no need to use it, we can replace it with newer events, but it can often be found in older scripts.
+
+If we need to track uploading specifically, then we should listen to same events on `xhr.upload` object.
diff --git a/5-network/07-xmlhttprequest/example.view/index.html b/5-network/07-xmlhttprequest/example.view/index.html
new file mode 100644
index 000000000..7dbc3d951
--- /dev/null
+++ b/5-network/07-xmlhttprequest/example.view/index.html
@@ -0,0 +1,30 @@
+<!DOCTYPE HTML>
+<script>
+function run() {
+
+  let xhr = new XMLHttpRequest();
+  write(`readyState=${xhr.readyState}`);
+
+  xhr.open('GET', 'digits');
+  write(`readyState=${xhr.readyState}`);
+
+  xhr.onreadystatechange = function() {
+    write(`readyState=${xhr.readyState}, responseText.length=${xhr.responseText.length}`);
+  };
+
+  xhr.onprogress = function() {
+    write(`readyState=${xhr.readyState}, responseText.length=${xhr.responseText.length}`);
+  };
+
+  xhr.send();
+}
+
+function write(text) {
+  let li = log.appendChild(document.createElement('li'));
+  li.innerHTML = text;
+}
+</script>
+
+<button onclick="run()">Load digits</button>
+
+<ul id="log"></ul>
diff --git a/5-network/07-xmlhttprequest/example.view/server.js b/5-network/07-xmlhttprequest/example.view/server.js
new file mode 100644
index 000000000..a387293b9
--- /dev/null
+++ b/5-network/07-xmlhttprequest/example.view/server.js
@@ -0,0 +1,52 @@
+let http = require('http');
+let url = require('url');
+let querystring = require('querystring');
+let static = require('node-static');
+let file = new static.Server('.');
+
+function accept(req, res) {
+
+  if (req.url == '/load') {
+
+    res.writeHead(200, {
+      'Content-Type': 'text/plain',
+      'Cache-Control': 'no-cache',
+      'Content-Length': 90000
+    });
+
+    let i = 0;
+
+    let timer = setInterval(write, 1000);
+    write();
+
+    function write() {
+      res.write(String(i).repeat(10000));
+      i++;
+      if (i == 9) {
+        clearInterval(timer);
+        res.end();
+      }
+
+    }
+  } else if (req.url == '/json') {
+    res.writeHead(200, {
+      // 'Content-Type': 'application/json;charset=utf-8',
+      'Cache-Control': 'no-cache'
+    });
+
+    res.write(JSON.stringify({message: "Hello, world!"}));
+    res.end();
+  } else {
+    file.serve(req, res);
+  }
+}
+
+
+
+// ----- запуск accept как сервера из консоли или как модуля ------
+
+if (!module.parent) {
+  http.createServer(accept).listen(8080);
+} else {
+  exports.accept = accept;
+}
diff --git a/7-network/1-xmlhttprequest/hello.txt b/5-network/07-xmlhttprequest/hello.txt
similarity index 100%
rename from 7-network/1-xmlhttprequest/hello.txt
rename to 5-network/07-xmlhttprequest/hello.txt
diff --git a/7-network/1-xmlhttprequest/phones-async.view/index.html b/5-network/07-xmlhttprequest/phones-async.view/index.html
similarity index 100%
rename from 7-network/1-xmlhttprequest/phones-async.view/index.html
rename to 5-network/07-xmlhttprequest/phones-async.view/index.html
diff --git a/7-network/1-xmlhttprequest/phones-async.view/phones.json b/5-network/07-xmlhttprequest/phones-async.view/phones.json
similarity index 100%
rename from 7-network/1-xmlhttprequest/phones-async.view/phones.json
rename to 5-network/07-xmlhttprequest/phones-async.view/phones.json
diff --git a/7-network/1-xmlhttprequest/phones-async.view/server.js b/5-network/07-xmlhttprequest/phones-async.view/server.js
similarity index 100%
rename from 7-network/1-xmlhttprequest/phones-async.view/server.js
rename to 5-network/07-xmlhttprequest/phones-async.view/server.js
diff --git a/7-network/1-xmlhttprequest/phones.json b/5-network/07-xmlhttprequest/phones.json
old mode 100755
new mode 100644
similarity index 100%
rename from 7-network/1-xmlhttprequest/phones.json
rename to 5-network/07-xmlhttprequest/phones.json
diff --git a/7-network/1-xmlhttprequest/phones.view/index.html b/5-network/07-xmlhttprequest/phones.view/index.html
similarity index 100%
rename from 7-network/1-xmlhttprequest/phones.view/index.html
rename to 5-network/07-xmlhttprequest/phones.view/index.html
diff --git a/7-network/1-xmlhttprequest/phones.view/phones.json b/5-network/07-xmlhttprequest/phones.view/phones.json
similarity index 100%
rename from 7-network/1-xmlhttprequest/phones.view/phones.json
rename to 5-network/07-xmlhttprequest/phones.view/phones.json
diff --git a/7-network/1-xmlhttprequest/phones.view/server.js b/5-network/07-xmlhttprequest/phones.view/server.js
similarity index 100%
rename from 7-network/1-xmlhttprequest/phones.view/server.js
rename to 5-network/07-xmlhttprequest/phones.view/server.js
diff --git a/5-network/07-xmlhttprequest/post.view/index.html b/5-network/07-xmlhttprequest/post.view/index.html
new file mode 100644
index 000000000..ba7f76065
--- /dev/null
+++ b/5-network/07-xmlhttprequest/post.view/index.html
@@ -0,0 +1,36 @@
+<!doctype html>
+<script>
+(async () {
+	
+	const response = await fetch('long.txt');
+	const reader = response.body.getReader();
+
+	const contentLength = +response.headers.get('Content-Length');
+	let receivedLength = 0;
+	let chunks = [];
+	while(true) {
+		const chunk = await reader.read();
+
+		if (chunk.done) {
+			console.log("done!");
+			break;
+		}
+
+		chunks.push(chunk.value);
+		receivedLength += chunk.value.length;
+		console.log(`${receivedLength}/${contentLength} received`)
+	}
+
+
+	let chunksMerged = new Uint8Array(receivedLength);
+	let length = 0;
+	for(let chunk of chunks) {
+		chunksMerged.set(chunk, length);
+		length += chunk.length;
+	}
+
+	let result = new TextDecoder("utf-8").decode(chunksMerged);
+	console.log(result);
+})();
+
+</script>
diff --git a/5-network/07-xmlhttprequest/post.view/server.js b/5-network/07-xmlhttprequest/post.view/server.js
new file mode 100644
index 000000000..50cfc5ae3
--- /dev/null
+++ b/5-network/07-xmlhttprequest/post.view/server.js
@@ -0,0 +1,58 @@
+let http = require('http');
+let url = require('url');
+let querystring = require('querystring');
+let static = require('node-static');
+let file = new static.Server('.', {
+  cache: 0
+});
+
+
+function accept(req, res) {
+
+  if (req.method == 'POST') {
+    let chunks = [];
+    let length = 0;
+
+    req.on('data', function (data) {
+      chunks.push(data);
+      length += data.length;
+
+      // More than 10mb, kill the connection!
+      if (length > 1e8) {
+        req.connection.destroy();
+      }
+    });
+
+    req.on('end', function() {
+      // let post = JSON.parse(chunks.join(''));
+
+      if (req.url == '/user') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ message: 'User saved' }));
+      } else if (req.url == '/image') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ message: "Image saved", imageSize: length }));
+      } else if (req.url == '/upload') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ message: "Upload complete", size: length }));
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+
+
+  } else {
+    file.serve(req, res);
+  }
+
+}
+
+
+// ------ запустить сервер -------
+
+if (!module.parent) {
+  http.createServer(accept).listen(8080);
+} else {
+  exports.accept = accept;
+}
diff --git a/5-network/08-websocket/article.md b/5-network/08-websocket/article.md
new file mode 100644
index 000000000..f7bd1fa2c
--- /dev/null
+++ b/5-network/08-websocket/article.md
@@ -0,0 +1,385 @@
+# WebSocket
+
+The `WebSocket` protocol, described in the specification [RFC 6455](http://tools.ietf.org/html/rfc6455) provides a way to exchange data between browser and server via a persistent connection.
+
+Once a websocket connection is established, both client and server may send the data to each other.
+
+WebSocket is especially great for services that require continuous data exchange, e.g. online games, real-time trading systems and so on.
+
+## A simple example
+
+To open a websocket connection, we need to create `new WebSocket` using the special protocol `ws` in the url:
+
+```js
+let socket = new WebSocket("*!*ws*/!*://javascript.info");
+```
+
+There's also encrypted `wss://` protocol. It's like HTTPS for websockets.
+
+```smart header="Always prefer `wss://`"
+The `wss://` protocol not only encrypted, but also more reliable.
+
+That's because `ws://` data is not encrypted, visible for any intermediary. Old proxy servers do not know about WebSocket, they may see "strange" headers and abort the connection.
+
+On the other hand, `wss://` is WebSocket over TLS, (same as HTTPS is HTTP over TLS), the transport security layer encrypts the data at sender and decrypts at the receiver, so it passes encrypted through proxies. They can't see what's inside and let it through.
+```
+
+Once the socket is created, we should listen to events on it. There are totally 4 events:
+- **`open`** -- connection established,
+- **`message`** -- data received,
+- **`error`** -- websocket error,
+- **`close`** -- connection closed.
+
+...And if we'd like to send something, then `socket.send(data)` will do that.
+
+Here's an example:
+
+```js run
+let socket = new WebSocket("wss://javascript.info/article/websocket/demo/hello");
+
+socket.onopen = function(e) {
+  alert("[open] Connection established, send -> server");
+  socket.send("My name is John");
+};
+
+socket.onmessage = function(event) {
+  alert(`[message] Data received: ${event.data} <- server`);
+};
+
+socket.onclose = function(event) {
+  if (event.wasClean) {  
+    alert(`[close] Connection closed cleanly, code=${event.code} reason=${event.reason}`);
+  } else {
+    // e.g. server process killed or network down
+    // event.code is usually 1006 in this case
+    alert('[close] Connection died');
+  }
+};
+
+socket.onerror = function(error) {
+  alert(`[error] ${error.message}`);
+};
+```
+
+For demo purposes, there's a small server [server.js](demo/server.js) written in Node.js, for the example above, running. It responds with "hello", then waits 5 seconds and closes the connection.
+
+So you'll see events `open` -> `message` -> `close`.
+
+That's actually it, we can talk WebSocket already. Quite simple, isn't it?
+
+Now let's talk more in-depth.
+
+## Opening a websocket
+
+When `new WebSocket(url)` is created, it starts an HTTP handshake (HTTPS for `wss://`).
+
+The browser asks the server: "Do you support Websocket?" And if the server says "yes", then the talk continues in WebSocket protocol, which is not HTTP at all.
+
+![](websocket-handshake.png)
+
+Here's an example of browser request for `new WebSocket("wss://javascript.info/chat")`.
+
+```
+GET /chat
+Host: javascript.info
+Origin: https://javascript.info
+Connection: Upgrade
+Upgrade: websocket
+Sec-WebSocket-Key: Iv8io/9s+lYFgZWcXczP8Q==
+Sec-WebSocket-Version: 13
+```
+
+- `Origin` -- the origin of the client page. WebSocket is cross-origin by nature. There are no special headers or other limitations. Old servers are unable to handle WebSocket anyway, so there are no compabitility issues. But `Origin` header is important, as it allows the server to decide whether or not to talk WebSocket with this website.
+- `Connection: Upgrade` -- signals that the client would like to change the protocol.
+- `Upgrade: websocket` -- the requested protocol is "websocket".
+- `Sec-WebSocket-Key` -- a random browser-generated key for security.
+- `Sec-WebSocket-Version` -- WebSocket protocol version, 13 is the current one.
+
+```smart header="WebSocket handshake can't be emulated"
+We can't use `XMLHttpRequest` or `fetch` to make this kind of HTTP-request, because JavaScript is not allowed to set these headers.
+```
+
+If the server agrees to switch to WebSocket, it should send code 101 response:
+
+```
+101 Switching Protocols
+Upgrade: websocket
+Connection: Upgrade
+Sec-WebSocket-Accept: hsBlbuDTkk24srzEOTBUlZAlC2g=
+```
+
+Here `Sec-WebSocket-Accept` is `Sec-WebSocket-Key`, recoded using a special algorithm. The browser uses it to make sure that the response corresponds to the request.
+
+Afterwards, the data is transfered using WebSocket protocol, we'll see its structure ("frames") soon. And that's not HTTP at all.
+
+### Extensions and subprotocols
+
+There may be additional headers `Sec-WebSocket-Extensions` and `Sec-WebSocket-Protocol` that describe extensions and subprotocols.
+
+For instance:
+
+- `Sec-WebSocket-Extensions: deflate-frame` means that the browser supports data compression. An extension is something related to transferring the data, not data itself.
+
+- `Sec-WebSocket-Protocol: soap, wamp` means that we're going to transfer not just any data, but the data in [SOAP](http://en.wikipedia.org/wiki/SOAP) or WAMP ("The WebSocket Application Messaging Protocol") protocols. WebSocket subprotocols are registered in the [IANA catalogue](http://www.iana.org/assignments/websocket/websocket.xml).
+
+`Sec-WebSocket-Extensions` is sent by the browser automatically, with a list of possible extensions it supports.
+
+`Sec-WebSocket-Protocol` is depends on us: we decide what kind of data we send. The second optional parameter of `new WebSocket` lists subprotocols:
+
+```js
+let socket = new WebSocket("wss://javascript.info/chat", ["soap", "wamp"]);
+```
+
+The server should respond with a list of protocls and extensions that it agrees to use.
+
+For example, the request:
+
+```
+GET /chat
+Host: javascript.info
+Upgrade: websocket
+Connection: Upgrade
+Origin: https://javascript.info
+Sec-WebSocket-Key: Iv8io/9s+lYFgZWcXczP8Q==
+Sec-WebSocket-Version: 13
+*!*
+Sec-WebSocket-Extensions: deflate-frame
+Sec-WebSocket-Protocol: soap, wamp
+*/!*
+```
+
+Response:
+
+```
+101 Switching Protocols
+Upgrade: websocket
+Connection: Upgrade
+Sec-WebSocket-Accept: hsBlbuDTkk24srzEOTBUlZAlC2g=
+*!*
+Sec-WebSocket-Extensions: deflate-frame
+Sec-WebSocket-Protocol: soap
+*/!*
+```
+
+Here the server responds that it supports the extension `deflate-frame`, and only SOAP of the requested subprotocols.
+
+## WebSocket data
+
+WebSocket communication consists of "frames" that can be sent from either side:
+
+- "text frames" -- contain text data that parties send to each other.
+- "binary data frames" -- contain binary data that parties send to each other.
+- "ping/pong frames" are used to check the connection, sent from the server, the browser responds to these automatically.
+- "connection close frame" and a few other service frames.
+
+In the browser, we only care about text or binary frames.
+
+**WebSocket `.send()` can send either text or binary data, doesn't matter.**
+
+For sending, `socket.send(body)` allows strings or any binary format, including `Blob`, `ArrayBuffer`, etc. No settings required: just send it out.
+
+**Textual data always comes as string. For receiving binary data, we can choose between `Blob` and `ArrayBuffer` formats.**
+
+The `socket.bufferType` is `"blob"` by default, so binary data comes in Blobs.
+
+[Blob](info:blob) is a high-level binary object, it directly integrates with `<a>`, `<img>` and other tags, so that's a sane default. But for binary processing, to access individual data bytes, we can change it to `"arraybuffer"`:
+
+```js
+socket.bufferType = "arraybuffer";
+socket.onmessage = (event) => {
+  // event.data is either a string (if text) or arraybuffer (if binary)
+};
+```
+
+## Rate limiting
+
+Imagine, our app is generating a lot of data to send. But network connection is not that fast. The user may be on a mobile, in rural area.
+
+We can call `socket.send(data)` again and again. But the data will be buffered in memory and sent out only as fast as network speed allows.
+
+The `socket.bufferedAmount` property stores how many bytes are buffered at this moment, waiting to be sent over the network.
+
+We can examine it to see whether the socket is actually available for transmission.
+
+```js
+// every 100ms examine the socket and send more data only if no data buffered
+setInterval(() => {
+  if (socket.bufferedAmount == 0) {
+    socket.send(moreData());
+  }
+}, 100);
+```
+
+
+## Connection close
+
+Normally, when a party wants to close the connection (both browser and server have equal rights), they send a "connection close frame" with a numeric code and a textual reason.
+
+The method is:
+```js
+socket.close([code], [reason]);
+```
+
+Then the other party in `close` event handle can get the code and the reason, e.g.:
+
+```js
+// one party:
+socket.close(1000, "Work complete");
+
+// another party
+socket.onclose = event => {
+  // event.code === 1000
+  // event.reason === "Work complete"
+  // event.wasClean === true (clean close)
+};
+```
+
+The `code` is not just any number, but a special WebSocket closing code.
+
+Most common values:
+
+- `1000` -- the default, normal closure,
+- `1006` -- can't set such code manually, indicates that the connection was broken (no close frame).
+
+There are other codes like:
+
+- `1001` -- the party is going away, e.g. server is shutting down, or a browser leaves the page,
+- `1009` -- the message is too big to process,
+- `1011` -- unexpected error on server,
+- ...and so on.
+
+Please refer to the [RFC6455, §7.4.1](https://tools.ietf.org/html/rfc6455#section-7.4.1) for the full list.
+
+WebSocket codes are somewhat like HTTP codes, but different. In particular, an codes less than `1000` are reserved, there'll be an error if we try to set such a code.
+
+```js
+// in case connection is broken
+socket.onclose = event => {
+  // event.code === 1006
+  // event.reason === ""
+  // event.wasClean === false (no closing frame)
+};
+```
+
+
+## Connection state
+
+To get connection state, additionally there's `socket.readyState` property with values:
+
+- **`0`** -- "CONNECTING": the connection has not yet been established,
+- **`1`** -- "OPEN": communicating,
+- **`2`** -- "CLOSING": the connection is closing,
+- **`3`** -- "CLOSED": the connection is closed.
+
+
+## Chat example
+
+Let's review a chat example using browser WebSocket API and Node.js WebSocket module <https://github.com/websockets/ws>.
+
+HTML: there's a `<form>` to send messages and a `<div>` for incoming messages:
+
+```html
+<!-- message form -->
+<form name="publish">
+  <input type="text" name="message">
+  <input type="submit" value="Send">
+</form>
+
+<!-- div with messages -->
+<div id="messages"></div>
+```
+
+JavaScript is also simple. We open a socket, then on form submission -- `socket.send(message)`, on incoming message -- append it to `div#messages`:
+
+```js
+let socket = new WebSocket("wss://javascript.info/article/websocket/chat/ws");
+
+// send message from the form
+document.forms.publish.onsubmit = function() {
+  let outgoingMessage = this.message.value;
+
+  socket.send(outgoingMessage);
+  return false;
+};
+
+// show message in div#messages
+socket.onmessage = function(event) {
+  let message = event.data;
+
+  let messageElem = document.createElement('div');
+  messageElem.textContent = message;
+  document.getElementById('messages').prepend(messageElem);
+}
+```
+
+Server-side code is a little bit beyound our scope here. We're using browser WebSocket API, a server may have another library.
+
+Still it can also be pretty simple. We'll use Node.js with <https://github.com/websockets/ws> module for websockets.
+
+The algorithm will be:
+1. Create `clients = new Set()` -- a set of sockets.
+2. For each accepted websocket, `clients.add(socket)` and listen for its messages.
+3. When a message received: iterate over clients and send it to everyone.
+4. When a connection is closed: `clients.delete(socket)`.
+
+```js
+const ws = new require('ws');
+const wss = new ws.Server({noServer: true});
+
+const clients = new Set();
+
+http.createServer((req, res) => {
+  // in real project we have additional code here to handle non-websocket requests
+  wss.handleUpgrade(req, req.socket, Buffer.alloc(0), onSocketConnect);
+});
+
+function onSocketConnect(ws) {
+  clients.add(ws);
+
+  ws.on('message', function(message) {
+    message = message.slice(0, 50); // max message length will be 50
+
+    for(let client of clients) {
+      client.send(message);
+    }
+  });
+
+  ws.on('close', function() {
+    clients.delete(ws);
+  });
+}
+```
+
+
+Here's the working example:
+
+[iframe src="chat" height="100" zip]
+
+You can also download it (upper-right button in the iframe) and run locally. Just don't forget to install [Node.js](https://nodejs.org/en/) and `npm install ws` before running.
+
+
+## Summary
+
+WebSocket is a modern way to have persisten browser-server connections.
+
+- WebSockets don't have cross-origin limitations.
+- They are well-supported in browsers.
+- Can send/receive strings and binary data.
+
+The API is simple.
+
+Methods:
+- `socket.send(data)`,
+- `socket.close([code], [reason])`.
+
+Events:
+- `open`,
+- `message`,
+- `error`,
+- `close`.
+
+WebSocket by itself does not include reconnection, authentication and many other high-level mechanisms. So there are client/server libraries add them. But it's also possible to implement these manually and integrate WebSockets with an existing site.
+
+For integration purposes, a WebSocket server is usually running in parallel with the main server, and they share a single database. Requests to WebSocket use `wss://ws.site.com`, a subdomain that leads to WebSocket server, while `https://site.com` goes to the main HTTP-server.
+
+Surely, other ways of integration are also possible. Many servers (such as Node.js) can support both HTTP and WebSocket protocols.
diff --git a/5-network/08-websocket/chat.view/index.html b/5-network/08-websocket/chat.view/index.html
new file mode 100644
index 000000000..3dd4c24cd
--- /dev/null
+++ b/5-network/08-websocket/chat.view/index.html
@@ -0,0 +1,39 @@
+<!doctype html>
+<form name="publish">
+  <input type="text" name="message" maxlength="50"/>
+  <input type="submit" value="Send"/>
+</form>
+
+<div id="messages"></div>
+
+<script>
+let url = location.host == 'localhost' ?
+  'ws://localhost:8080/ws' : location.host == 'javascript.local' ?
+  `ws://javascript.local/article/websocket/chat/ws` : // dev integration with local site
+  `wss://javascript.info/article/websocket/chat/ws`; // prod integration with javascript.info
+
+let socket = new WebSocket(url);
+
+// send message from the form
+document.forms.publish.onsubmit = function() {
+  let outgoingMessage = this.message.value;
+
+  socket.send(outgoingMessage);
+  return false;
+};
+
+// handle incoming messages
+socket.onmessage = function(event) {
+  let incomingMessage = event.data;
+  showMessage(incomingMessage);
+};
+
+socket.onclose = event => console.log(`Closed ${event.code}`);
+
+// show message in div#messages
+function showMessage(message) {
+  let messageElem = document.createElement('div');
+  messageElem.textContent = message;
+  document.getElementById('messages').prepend(messageElem);
+}
+</script>
diff --git a/5-network/08-websocket/chat.view/server.js b/5-network/08-websocket/chat.view/server.js
new file mode 100644
index 000000000..d21973fc7
--- /dev/null
+++ b/5-network/08-websocket/chat.view/server.js
@@ -0,0 +1,61 @@
+/**
+Before running:
+> npm install ws
+Then:
+> node server.js
+> open http://localhost:8080 in the browser
+*/
+
+const http = require('http');
+const fs = require('fs');
+const ws = new require('ws');
+
+const wss = new ws.Server({noServer: true});
+
+const clients = new Set();
+
+function accept(req, res) {
+
+  if (req.url == '/ws' && req.headers.upgrade &&
+      req.headers.upgrade.toLowerCase() == 'websocket' &&
+      // can be Connection: keep-alive, Upgrade
+      req.headers.connection.match(/\bupgrade\b/i)) {
+    wss.handleUpgrade(req, req.socket, Buffer.alloc(0), onSocketConnect);
+  } else if (req.url == '/') { // index.html
+    fs.createReadStream('./index.html').pipe(res);
+  } else { // page not found
+    res.writeHead(404);
+    res.end();
+  }
+}
+
+function onSocketConnect(ws) {
+  clients.add(ws);
+  log(`new connection`);
+
+  ws.on('message', function(message) {
+    log(`message received: ${message}`);
+
+    message = message.slice(0, 50); // max message length will be 50
+
+    for(let client of clients) {
+      client.send(message);
+    }
+  });
+
+  ws.on('close', function() {
+    log(`connection closed`);
+    clients.delete(ws);
+  });
+}
+
+let log;
+if (!module.parent) {
+  log = console.log;
+  http.createServer(accept).listen(8080);
+} else {
+  // to embed into javascript.info
+  log = function() {};
+  // log = console.log;
+  exports.accept = accept;
+}
diff --git a/5-network/08-websocket/demo.view/server.js b/5-network/08-websocket/demo.view/server.js
new file mode 100644
index 000000000..7b17734d7
--- /dev/null
+++ b/5-network/08-websocket/demo.view/server.js
@@ -0,0 +1,34 @@
+const http = require('http');
+const ws = require('ws');
+
+const wss = new ws.Server({noServer: true});
+
+function accept(req, res) {
+  // all incoming requests must be websockets
+  if (!req.headers.upgrade || req.headers.upgrade.toLowerCase() != 'websocket') {
+    res.end();
+    return;
+  }
+  // can be Connection: keep-alive, Upgrade
+  if (req.headers.connection.match(/\bupgrade\b/i)) {
+    res.end();
+    return;
+  }
+
+  wss.handleUpgrade(req, req.socket, Buffer.alloc(0), onConnect);
+}
+
+function onConnect(ws) {
+  ws.on('message', function (message) {
+    let name = message.match(/\w+$/) || "Guest";
+    ws.send(`Hello, ${name}!`);
+
+    setTimeout(() => ws.close(1000, "Bye!"), 5000);
+  });
+}
+
+if (!module.parent) {
+  http.createServer(accept).listen(8080);
+} else {
+  exports.accept = accept;
+}
diff --git a/5-network/08-websocket/websocket-handshake.png b/5-network/08-websocket/websocket-handshake.png
new file mode 100644
index 000000000..74ca42520
Binary files /dev/null and b/5-network/08-websocket/websocket-handshake.png differ
diff --git a/5-network/08-websocket/websocket-handshake@2x.png b/5-network/08-websocket/websocket-handshake@2x.png
new file mode 100644
index 000000000..34a261027
Binary files /dev/null and b/5-network/08-websocket/websocket-handshake@2x.png differ
diff --git a/5-network/index.md b/5-network/index.md
new file mode 100644
index 000000000..31f86f092
--- /dev/null
+++ b/5-network/index.md
@@ -0,0 +1,2 @@
+
+# Network requests
diff --git a/5-regular-expressions/02-regexp-methods/article.md b/5-regular-expressions/02-regexp-methods/article.md
deleted file mode 100644
index fb023c742..000000000
--- a/5-regular-expressions/02-regexp-methods/article.md
+++ /dev/null
@@ -1,407 +0,0 @@
-# Methods of RegExp and String
-
-There are two sets of methods to deal with regular expressions.
-
-1. First, regular expressions are objects of the built-in [RegExp](mdn:js/RegExp) class, it provides many methods.
-2. Besides that, there are methods in regular strings can work with regexps.
-
-The structure is a bit messed up, so we'll first consider methods separately, and then -- practical recipes for common tasks.
-
-## str.search(reg)
-
-We've seen this method already. It returns the position of the first match or `-1` if none found:
-
-```js run
-let str = "A drop of ink may make a million think";
-
-alert( str.search( *!*/a/i*/!* ) ); // 0 (the first position)
-```
-
-**The important limitation: `search` always looks for the first match.**
-
-We can't find next positions using `search`, there's just no syntax for that. But there are other methods that can.
-
-## str.match(reg), no "g" flag
-
-The method `str.match` behavior varies depending on the `g` flag. First let's see the case without it.
-
-Then `str.match(reg)` looks for the first match only.
-
-The result is an array with that match and additional properties:
-
-- `index` -- the position of the match inside the string,
-- `input` -- the subject string.
-
-For instance:
-
-```js run
-let str = "Fame is the thirst of youth";
-
-let result = str.match( *!*/fame/i*/!* );
-
-alert( result[0] );    // Fame (the match)
-alert( result.index ); // 0 (at the zero position)
-alert( result.input ); // "Fame is the thirst of youth" (the string)
-```
-
-The array may have more than one element.
-
-**If a part of the pattern is delimited by parentheses `(...)`, then it becomes a separate element of the array.**
-
-For instance:
-
-```js run
-let str = "JavaScript is a programming language";
-
-let result = str.match( *!*/JAVA(SCRIPT)/i*/!* );
-
-alert( result[0] ); // JavaScript (the whole match)
-alert( result[1] ); // script (the part of the match that corresponds to the parentheses)
-alert( result.index ); // 0
-alert( result.input ); // JavaScript is a programming language
-```
-
-Due to the `i` flag the search is case-insensitive, so it finds `match:JavaScript`. The part of the match that corresponds to `pattern:SCRIPT` becomes a separate array item.
-
-We'll be back to parentheses later in the chapter <info:regexp-groups>. They are great for search-and-replace.
-
-## str.match(reg) with "g" flag
-
-When there's a `"g"` flag, then `str.match` returns an array of all matches. There are no additional properties in that array, and parentheses do not create any elements.
-
-For instance:
-
-```js run
-let str = "HO-Ho-ho!";
-
-let result = str.match( *!*/ho/ig*/!* );
-
-alert( result ); // HO, Ho, ho (all matches, case-insensitive)
-```
-
-With parentheses nothing changes, here we go:
-
-```js run
-let str = "HO-Ho-ho!";
-
-let result = str.match( *!*/h(o)/ig*/!* );
-
-alert( result ); // HO, Ho, ho
-```
-
-So, with `g` flag the `result` is a simple array of matches. No additional properties.
-
-If we want to get information about match positions and use parentheses then we should use  [RegExp#exec](mdn:js/RegExp/exec) method that we'll cover below.
-
-````warn header="If there are no matches, the call to `match` returns `null`"
-Please note, that's important. If there were no matches, the result is not an empty array, but `null`.
-
-Keep that in mind to evade pitfalls like this:
-
-```js run
-let str = "Hey-hey-hey!";
-
-alert( str.match(/ho/gi).length ); // error! there's no length of null
-```
-````
-
-## str.split(regexp|substr, limit)
-
-Splits the string using the regexp (or a substring) as a delimiter.
-
-We already used `split` with strings, like this:
-
-```js run
-alert('12-34-56'.split('-')) // [12, 34, 56]
-```
-
-But we can also pass a regular expression:
-
-```js run
-alert('12-34-56'.split(/-/)) // [12, 34, 56]
-```
-
-## str.replace(str|reg, str|func)
-
-The swiss army knife for search and replace in strings.
-
-The simplest use -- search and replace a substring, like this:
-
-```js run
-// replace a dash by a colon
-alert('12-34-56'.replace("-", ":")) // 12:34-56
-```
-
-When the first argument of `replace` is a string, it only looks for the first match.
-
-To find all dashes, we need to use not the string `"-"`, but a regexp `pattern:/-/g`, with an obligatory `g` flag:
-
-```js run
-// replace all dashes by a colon
-alert( '12-34-56'.replace( *!*/-/g*/!*, ":" ) )  // 12:34:56
-```
-
-The second argument is a replacement string.
-
-We can use special characters in it:
-
-| Symbol | Inserts |
-|--------|--------|
-|`$$`|`"$"` |
-|`$&`|the whole match|
-|<code>$&#096;</code>|a part of the string before the match|
-|`$'`|a part of the string after the match|
-|`$n`|if `n` is a 1-2 digit number, then it means the contents of n-th parentheses counting from left to right|
-
-For instance let's use `$&` to replace all entries of `"John"` by `"Mr.John"`:
-
-```js run
-let str = "John Doe, John Smith and John Bull.";
-
-// for each John - replace it with Mr. and then John
-alert(str.replace(/John/g, 'Mr.$&'));
-// "Mr.John Doe, Mr.John Smith and Mr.John Bull.";
-```
-
-Parentheses are very often used together with `$1`, `$2`, like this:
-
-```js run
-let str = "John Smith";
-
-alert(str.replace(/(John) (Smith)/, '$2, $1')) // Smith, John
-```
-
-**For situations that require "smart" replacements, the second argument can be a function.**
-
-It will be called for each match, and its result will be inserted as a replacement.
-
-For instance:
-
-```js run
-let i = 0;
-
-// replace each "ho" by the result of the function
-alert("HO-Ho-ho".replace(/ho/gi, function() {
-  return ++i;
-})); // 1-2-3
-```
-
-In the example above the function just returns the next number every time, but usually the result is based on the match.
-
-The function is called with arguments `func(str, p1, p2, ..., pn, offset, s)`:
-
-1. `str` -- the match,
-2. `p1, p2, ..., pn` -- contents of parentheses (if there are any),
-3. `offset` -- position of the match,
-4. `s` -- the source string.
-
-If there are no parentheses in the regexp, then the function always has 3 arguments: `func(str, offset, s)`.
-
-Let's use it to show full information about matches:
-
-```js run
-// show and replace all matches
-function replacer(str, offset, s) {
-  alert(`Found ${str} at position ${offset} in string ${s}`);
-  return str.toLowerCase();
-}
-
-let result = "HO-Ho-ho".replace(/ho/gi, replacer);
-alert( 'Result: ' + result ); // Result: ho-ho-ho
-
-// shows each match:
-// Found HO at position 0 in string HO-Ho-ho
-// Found Ho at position 3 in string HO-Ho-ho
-// Found ho at position 6 in string HO-Ho-ho
-```
-
-In the example below there are two parentheses, so `replacer` is called with 5 arguments: `str` is the full match, then parentheses, and then `offset` and `s`:
-
-```js run
-function replacer(str, name, surname, offset, s) {
-  // name is the first parentheses, surname is the second one
-  return surname + ", " + name;
-}
-
-let str = "John Smith";
-
-alert(str.replace(/(John) (Smith)/, replacer)) // Smith, John
-```
-
-Using a function gives us the ultimate replacement power, because it gets all the information about the match, has access to outer variables and can do everything.
-
-## regexp.test(str)
-
-Let's move on to the methods of `RegExp` class, that are callable on regexps themselves.
-
-The `test` method looks for any match and returns `true/false` whether they found it.
-
-So it's basically the same as `str.search(reg) != -1`, for instance:
-
-```js run
-let str = "I love JavaScript";
-
-// these two tests do the same
-alert( *!*/love/i*/!*.test(str) ); // true
-alert( str.search(*!*/love/i*/!*) != -1 ); // true
-```
-
-An example with the negative answer:
-
-```js run
-let str = "Bla-bla-bla";
-
-alert( *!*/love/i*/!*.test(str) ); // false
-alert( str.search(*!*/love/i*/!*) != -1 ); // false
-```
-
-## regexp.exec(str)
-
-We've already seen these searching methods:
-
-- `search` -- looks for the position of the match,
-- `match` -- if there's no `g` flag, returns the first match with parentheses,
-- `match` -- if there's a `g` flag -- returns all matches, without separating parentheses.
-
-The `regexp.exec` method is a bit harder to use, but it allows to search all matches with parentheses and positions.
-
-It behaves differently depending on whether the regexp has the `g` flag.
-
-- If there's no `g`, then `regexp.exec(str)` returns the first match, exactly as `str.match(reg)`.
-- If there's `g`, then `regexp.exec(str)` returns the first match and *remembers* the position after it in `regexp.lastIndex` property. The next call starts to search from `regexp.lastIndex` and returns the next match. If there are no more matches then `regexp.exec` returns `null` and `regexp.lastIndex` is set to `0`.
-
-As we can see, the method gives us nothing new if we use it without the `g` flag, because `str.match` does exactly the same.
-
-But the `g` flag allows to get all matches with their positions and parentheses groups.
-
-Here's the example how subsequent `regexp.exec` calls return matches one by one:
-
-```js run
-let str = "A lot about JavaScript at https://javascript.info";
-
-let regexp = /JAVA(SCRIPT)/ig;
-
-*!*
-// Look for the first match
-*/!*
-let matchOne = regexp.exec(str);
-alert( matchOne[0] ); // JavaScript
-alert( matchOne[1] ); // script
-alert( matchOne.index ); // 12 (the position of the match)
-alert( matchOne.input ); // the same as str
-
-alert( regexp.lastIndex ); // 22 (the position after the match)
-
-*!*
-// Look for the second match
-*/!*
-let matchTwo = regexp.exec(str); // continue searching from regexp.lastIndex
-alert( matchTwo[0] ); // javascript
-alert( matchTwo[1] ); // script
-alert( matchTwo.index ); // 34 (the position of the match)
-alert( matchTwo.input ); // the same as str
-
-alert( regexp.lastIndex ); // 44 (the position after the match)
-
-*!*
-// Look for the third match
-*/!*
-let matchThree = regexp.exec(str); // continue searching from regexp.lastIndex
-alert( matchThree ); // null (no match)
-
-alert( regexp.lastIndex ); // 0 (reset)
-```
-
-As we can see, each `regexp.exec` call returns the match in a "full format": as an array with parentheses, `index` and `input` properties.
-
-The main use case for `regexp.exec` is to find all matches in a loop:
-
-```js run
-let str = 'A lot about JavaScript at https://javascript.info';
-
-let regexp = /javascript/ig;
-
-let result;
-
-while (result = regexp.exec(str)) {
-  alert( `Found ${result[0]} at ${result.index}` );
-}
-```
-
-The loop continues until `regexp.exec` returns `null` that means "no more matches".
-
-````smart header="Search from the given position"
-We can force `regexp.exec` to start searching from the given position by setting `lastIndex` manually:
-
-```js run
-let str = 'A lot about JavaScript at https://javascript.info';
-
-let regexp = /javascript/ig;
-regexp.lastIndex = 30;
-
-alert( regexp.exec(str).index ); // 34, the search starts from the 30th position
-```
-````
-
-## The "y" flag [#y-flag]
-
-The `y` flag means that the search should find a match exactly at the position specified by the property `regexp.lastIndex` and only there.
-
-In other words, normally the search is made in the whole string: `pattern:/javascript/` looks for "javascript" everywhere in the string.
-
-But when a regexp has the `y` flag, then it only looks for the match at the position specified in `regexp.lastIndex` (`0` by default).
-
-For instance:
-
-```js run
-let str = "I love JavaScript!";
-
-let reg = /javascript/iy;
-
-alert( reg.lastIndex ); // 0 (default)
-alert( str.match(reg) ); // null, not found at position 0
-
-reg.lastIndex = 7;
-alert( str.match(reg) ); // JavaScript (right, that word starts at position 7)
-
-// for any other reg.lastIndex the result is null
-```
-
-The regexp `pattern:/javascript/iy` can only be found if we set `reg.lastIndex=7`, because due to `y` flag the engine only tries to find it in the single place within a string -- from the `reg.lastIndex` position.
-
-So, what's the point? Where do we apply that?
-
-The reason is performance.
-
-The `y` flag works great for parsers -- programs that need to "read" the text and build in-memory syntax structure or perform actions from it. For that we move along the text and apply regular expressions to see what we have next: a string? A number? Something else?
-
-The `y` flag allows to apply a regular expression (or many of them one-by-one) exactly at the given position and when we understand what's there, we can move on -- step by step examining the text.
-
-Without the flag the regexp engine always searches till the end of the text, that takes time, especially if the text is large. So our parser would be very slow. The `y` flag is exactly the right thing here.
-
-## Summary, recipes
-
-Methods become much easier to understand if we separate them by their use in real-life tasks.
-
-To search for the first match only:
-: - Find the position of the first match -- `str.search(reg)`.
-- Find the full match -- `str.match(reg)`.
-- Check if there's a match -- `regexp.test(str)`.
-- Find the match from the given position -- `regexp.exec(str)`, set `regexp.lastIndex` to position.
-
-To search for all matches:
-: - An array of matches -- `str.match(reg)`, the regexp with `g` flag.
-- Get all matches with full information about each one -- `regexp.exec(str)` with `g` flag in the loop.
-
-To search and replace:
-: - Replace with another string or a function result -- `str.replace(reg, str|func)`
-
-To split the string:
-: - `str.split(str|reg)`
-
-We also covered two flags:
-
-- The `g` flag to find all matches (global search),
-- The `y` flag to search at exactly the given position inside the text.
-
-Now we know the methods and can use regular expressions. But we need to learn their syntax, so let's move on.
diff --git a/5-regular-expressions/03-regexp-character-classes/hello-java-boundaries.png b/5-regular-expressions/03-regexp-character-classes/hello-java-boundaries.png
deleted file mode 100644
index ba293e6da..000000000
Binary files a/5-regular-expressions/03-regexp-character-classes/hello-java-boundaries.png and /dev/null differ
diff --git a/5-regular-expressions/03-regexp-character-classes/hello-java-boundaries@2x.png b/5-regular-expressions/03-regexp-character-classes/hello-java-boundaries@2x.png
deleted file mode 100644
index 9ebf623b3..000000000
Binary files a/5-regular-expressions/03-regexp-character-classes/hello-java-boundaries@2x.png and /dev/null differ
diff --git a/5-regular-expressions/03-regexp-character-classes/love-html5-classes.png b/5-regular-expressions/03-regexp-character-classes/love-html5-classes.png
deleted file mode 100644
index b8ed77c0f..000000000
Binary files a/5-regular-expressions/03-regexp-character-classes/love-html5-classes.png and /dev/null differ
diff --git a/5-regular-expressions/03-regexp-character-classes/love-html5-classes@2x.png b/5-regular-expressions/03-regexp-character-classes/love-html5-classes@2x.png
deleted file mode 100644
index 9fb998b98..000000000
Binary files a/5-regular-expressions/03-regexp-character-classes/love-html5-classes@2x.png and /dev/null differ
diff --git a/5-regular-expressions/04-regexp-escaping/article.md b/5-regular-expressions/04-regexp-escaping/article.md
deleted file mode 100644
index 11767c3dd..000000000
--- a/5-regular-expressions/04-regexp-escaping/article.md
+++ /dev/null
@@ -1,91 +0,0 @@
-
-# Escaping, special characters
-
-As we've seen, a backslash `"\"` is used to denote character classes. So it's a special character.
-
-There are other special characters as well, that have special meaning in a regexp. They are used to do more powerful searches.
-
-Here's a full list of them: `pattern:[ \ ^ $ . | ? * + ( )`.
-
-Don't try to remember it -- when we deal with each of them separately, you'll know it by heart automatically.
-
-## Escaping
-
-To use a special character as a regular one, prepend it with a backslash.
-
-That's also called "escaping a character".
-
-For instance, we need to find a dot `pattern:'.'`. In a regular expression a dot means "any character except a newline", so if we really mean "a dot", let's put a backslash before it: `pattern:\.`.
-
-```js run
-alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1
-```
-
-Parentheses are also special characters, so if we want them, we should use `pattern:\(`. The example below looks for a string `"g()"`:
-
-```js run
-alert( "function g()".match(/g\(\)/) ); // "g()"
-```
-
-If we're looking for a backslash `\`, then we should double it:
-
-```js run
-alert( "1\\2".match(/\\/) ); // '\'
-```
-
-## A slash
-
-The slash symbol `'/'` is not a special character, but in JavaScript it is used to open and close the regexp: `pattern:/...pattern.../`, so we should escape it too.
-
-Here's what a search for a slash `'/'` looks like:
-
-```js run
-alert( "/".match(/\//) ); // '/'
-```
-
-From the other hand, the alternative `new RegExp` syntaxes does not require escaping it:
-
-```js run
-alert( "/".match(new RegExp("/")) ); // '/'
-```
-
-## new RegExp
-
-If we are creating a regular expression with `new RegExp`, then we need to do some more escaping.
-
-For instance, consider this:
-
-```js run
-let reg = new RegExp("\d\.\d");
-
-alert( "Chapter 5.1".match(reg) ); // null
-```
-
-It doesn't work, but why?
-
-The reason is string escaping rules. Look here:
-
-```js run
-alert("\d\.\d"); // d.d
-```
-
-Backslashes are used for escaping inside a string and string-specific special characters like `\n`. The quotes "consume" and interpret them, for instance:
-
-- `\n` -- becomes a newline character,
-- `\u1234` -- becomes the Unicode character with such code,
-- ...And when there's no special meaning: like `\d` or `\z`, then the backslash is simply removed.
-
-So the call to `new RegExp` gets a string without backslashes.
-
-To fix it, we need to double backslashes, because quotes turn `\\` into `\`:
-
-```js run
-*!*
-let regStr = "\\d\\.\\d";
-*/!*
-alert(regStr); // \d\.\d (correct now)
-
-let reg = new RegExp(regStr);
-
-alert( "Chapter 5.1".match(reg) ); // 5.1
-```
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy1.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy1.png
deleted file mode 100644
index 5db6f17a8..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy1.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy1@2x.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy1@2x.png
deleted file mode 100644
index 966e27aa8..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy1@2x.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy2.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy2.png
deleted file mode 100644
index 9fdbe2343..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy2.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy2@2x.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy2@2x.png
deleted file mode 100644
index 91e665824..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy2@2x.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy3.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy3.png
deleted file mode 100644
index aeef75bd6..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy3.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy3@2x.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy3@2x.png
deleted file mode 100644
index a8c62e60d..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy3@2x.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy4.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy4.png
deleted file mode 100644
index c18ab43ec..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy4.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy4@2x.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy4@2x.png
deleted file mode 100644
index 823a37171..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy4@2x.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy5.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy5.png
deleted file mode 100644
index 12442d2bd..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy5.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy5@2x.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy5@2x.png
deleted file mode 100644
index 29d3cf0af..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy5@2x.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy6.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy6.png
deleted file mode 100644
index 3ed72b25d..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy6.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy6@2x.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy6@2x.png
deleted file mode 100644
index 4833e6769..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy6@2x.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy3.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy3.png
deleted file mode 100644
index 1e0ce4178..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy3.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy3@2x.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy3@2x.png
deleted file mode 100644
index 1e378468d..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy3@2x.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy4.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy4.png
deleted file mode 100644
index 478834eec..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy4.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy4@2x.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy4@2x.png
deleted file mode 100644
index 495a2f243..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy4@2x.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy5.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy5.png
deleted file mode 100644
index e50543675..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy5.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy5@2x.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy5@2x.png
deleted file mode 100644
index 870d46330..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy5@2x.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy6.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy6.png
deleted file mode 100644
index 66728501c..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy6.png and /dev/null differ
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy6@2x.png b/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy6@2x.png
deleted file mode 100644
index 4228e193b..000000000
Binary files a/5-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy6@2x.png and /dev/null differ
diff --git a/5-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md b/5-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md
deleted file mode 100644
index becd6a8ff..000000000
--- a/5-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md
+++ /dev/null
@@ -1,16 +0,0 @@
-
-An integer number is `pattern:\d+`.
-
-A decimal part is: `pattern:\.\d+`.
-
-Because the decimal part is optional, let's put it in parentheses with the quantifier `pattern:'?'`.
-
-Finally we have the regexp: `pattern:\d+(\.\d+)?`:
-
-```js run
-let reg = /\d+(\.\d+)?/g;
-
-let str = "1.5 0 12. 123.4.";
-
-alert( str.match(reg) );   // 1.5, 0, 12, 123.4
-```
diff --git a/5-regular-expressions/09-regexp-groups/regexp-nested-groups.png b/5-regular-expressions/09-regexp-groups/regexp-nested-groups.png
deleted file mode 100644
index 4434b7be0..000000000
Binary files a/5-regular-expressions/09-regexp-groups/regexp-nested-groups.png and /dev/null differ
diff --git a/5-regular-expressions/09-regexp-groups/regexp-nested-groups@2x.png b/5-regular-expressions/09-regexp-groups/regexp-nested-groups@2x.png
deleted file mode 100644
index 2721e79d3..000000000
Binary files a/5-regular-expressions/09-regexp-groups/regexp-nested-groups@2x.png and /dev/null differ
diff --git a/5-regular-expressions/10-regexp-backreferences/article.md b/5-regular-expressions/10-regexp-backreferences/article.md
deleted file mode 100644
index a5d251078..000000000
--- a/5-regular-expressions/10-regexp-backreferences/article.md
+++ /dev/null
@@ -1,60 +0,0 @@
-# Backreferences: \n and $n
-
-Capturing groups may be accessed not only in the result, but in the replacement string, and in the pattern too.
-
-## Group in replacement: $n
-
-When we are using `replace` method, we can access n-th group in the replacement string using `$n`.
-
-For instance:
-
-```js run
-let name = "John Smith";
-
-name = name.replace(/(\w+) (\w+)/i, *!*"$2, $1"*/!*);
-alert( name ); // Smith, John
-```
-
-Here `pattern:$1` in the replacement string means "substitute the content of the first group here", and `pattern:$2` means "substitute the second group here".
-
-Referencing a group in the replacement string allows us to reuse the existing text during the replacement.
-
-## Group in pattern: \n
-
-A group can be referenced in the pattern using `\n`.
-
-To make things clear let's consider a task. We need to find a quoted string: either a single-quoted  `subject:'...'` or a double-quoted `subject:"..."` -- both variants need to match.
-
-How to look for them?
-
-We can put two kinds of quotes in the pattern: `pattern:['"](.*?)['"]`. That finds strings like  `match:"..."` and `match:'...'`, but it gives incorrect matches when one quote appears inside another one, like the string `subject:"She's the one!"`:
-
-```js run
-let str = "He said: \"She's the one!\".";
-
-let reg = /['"](.*?)['"]/g;
-
-// The result is not what we expect
-alert( str.match(reg) ); // "She'
-```
-
-As we can see, the pattern found an opening quote `match:"`, then the text is consumed lazily till the other quote `match:'`, that closes the match.
-
-To make sure that the pattern looks for the closing quote exactly the same as the opening one, let's make a group of it and use the backreference:
-
-```js run
-let str = "He said: \"She's the one!\".";
-
-let reg = /(['"])(.*?)\1/g;
-
-alert( str.match(reg) ); // "She's the one!"
-```
-
-Now everything's correct! The regular expression engine finds the first quote `pattern:(['"])` and remembers the content of `pattern:(...)`, that's the first capturing group.
-
-Further in the pattern `pattern:\1` means "find the same text as in the first group".
-
-Please note:
-
-- To reference a group inside a replacement string -- we use `$1`, while in the pattern -- a backslash `\1`.
-- If we use `?:` in the group, then we can't reference it. Groups that are excluded from capturing `(?:...)` are not remembered by the engine.
diff --git a/5-regular-expressions/14-regexp-lookahead/article.md b/5-regular-expressions/14-regexp-lookahead/article.md
deleted file mode 100644
index 70484b7d5..000000000
--- a/5-regular-expressions/14-regexp-lookahead/article.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Lookahead (in progress)
-
-The article is under development, will be here when it's ready.
diff --git a/6-async/01-callbacks/callback-hell.png b/6-async/01-callbacks/callback-hell.png
deleted file mode 100644
index f42224a26..000000000
Binary files a/6-async/01-callbacks/callback-hell.png and /dev/null differ
diff --git a/6-async/01-callbacks/callback-hell@2x.png b/6-async/01-callbacks/callback-hell@2x.png
deleted file mode 100644
index 7c9a3ab5e..000000000
Binary files a/6-async/01-callbacks/callback-hell@2x.png and /dev/null differ
diff --git a/6-async/02-promise-basics/promise-reject-1.png b/6-async/02-promise-basics/promise-reject-1.png
deleted file mode 100644
index 38f27c735..000000000
Binary files a/6-async/02-promise-basics/promise-reject-1.png and /dev/null differ
diff --git a/6-async/02-promise-basics/promise-reject-1@2x.png b/6-async/02-promise-basics/promise-reject-1@2x.png
deleted file mode 100644
index f9b748ff0..000000000
Binary files a/6-async/02-promise-basics/promise-reject-1@2x.png and /dev/null differ
diff --git a/6-async/02-promise-basics/promise-resolve-1.png b/6-async/02-promise-basics/promise-resolve-1.png
deleted file mode 100644
index 0dfe7bada..000000000
Binary files a/6-async/02-promise-basics/promise-resolve-1.png and /dev/null differ
diff --git a/6-async/02-promise-basics/promise-resolve-1@2x.png b/6-async/02-promise-basics/promise-resolve-1@2x.png
deleted file mode 100644
index 269b8f290..000000000
Binary files a/6-async/02-promise-basics/promise-resolve-1@2x.png and /dev/null differ
diff --git a/6-async/02-promise-basics/promise-resolve-reject.png b/6-async/02-promise-basics/promise-resolve-reject.png
deleted file mode 100644
index 505726efd..000000000
Binary files a/6-async/02-promise-basics/promise-resolve-reject.png and /dev/null differ
diff --git a/6-async/02-promise-basics/promise-resolve-reject@2x.png b/6-async/02-promise-basics/promise-resolve-reject@2x.png
deleted file mode 100644
index 31128dbe0..000000000
Binary files a/6-async/02-promise-basics/promise-resolve-reject@2x.png and /dev/null differ
diff --git a/6-async/03-promise-chaining/article.md b/6-async/03-promise-chaining/article.md
deleted file mode 100644
index d1a5cb920..000000000
--- a/6-async/03-promise-chaining/article.md
+++ /dev/null
@@ -1,684 +0,0 @@
-
-# Promises chaining
-
-Let's return to the problem mentioned in the chapter <info:callbacks>.
-
-- We have a sequence of asynchronous tasks to be done one after another. For instance, loading scripts.
-- How to code it well?
-
-Promises provide a couple of recipes to do that.
-
-In this chapter we cover promise chaining.
-
-It looks like this:
-
-```js run
-new Promise(function(resolve, reject) {
-
-  setTimeout(() => resolve(1), 1000); // (*)
-
-}).then(function(result) { // (**)
-
-  alert(result); // 1
-  return result * 2;
-
-}).then(function(result) { // (***)
-
-  alert(result); // 2
-  return result * 2;
-
-}).then(function(result) {
-
-  alert(result); // 4
-  return result * 2;
-
-});
-```
-
-The idea is that the result is passed through the chain of `.then` handlers.
-
-Here the flow is:
-1. The initial promise resolves in 1 second `(*)`,
-2. Then the `.then` handler is called `(**)`.
-3. The value that it returns is passed to the next `.then` handler `(***)`
-4. ...and so on.
-
-As the result is passed along the chain of handlers, we can see a sequence of `alert` calls: `1` -> `2` -> `4`.
-
-![](promise-then-chain.png)
-
-The whole thing works, because a call to `promise.then` returns a promise, so that we can call the next `.then` on it.
-
-When a handler returns a value, it becomes the result of that promise, so the next `.then` is called with it.
-
-To make these words more clear, here's the start of the chain:
-
-```js run
-new Promise(function(resolve, reject) {
-
-  setTimeout(() => resolve(1), 1000);
-
-}).then(function(result) {
-
-  alert(result);
-  return result * 2; // <-- (1)
-
-}) // <-- (2)
-// .then…
-```
-
-The value returned by `.then` is a promise, that's why we are able to add another `.then` at `(2)`. When the value is returned in `(1)`, that promise becomes resolved, so the next handler runs with the value.
-
-Unlike the chaining, technically we can also add many `.then` to a single promise, like this:
-
-```js run
-let promise = new Promise(function(resolve, reject) {
-  setTimeout(() => resolve(1), 1000);
-});
-
-promise.then(function(result) {
-  alert(result); // 1
-  return result * 2;
-});
-
-promise.then(function(result) {
-  alert(result); // 1
-  return result * 2;
-});
-
-promise.then(function(result) {
-  alert(result); // 1
-  return result * 2;
-});
-```
-
-...But that's a totally different thing. Here's the picture (compare it with the chaining above):
-
-![](promise-then-many.png)
-
-All `.then` on the same promise get the same result -- the result of that promise. So in the code above all `alert` show the same: `1`. There is no result-passing between them.
-
-In practice we rarely need multiple handlers for one promise. Chaining is used much more often.
-
-## Returning promises
-
-Normally, a value returned by a `.then` handler is immediately passed to the next handler. But there's an exception.
-
-If the returned value is a promise, then the further execution is suspended until it settles. After that, the result of that promise is given to the next `.then` handler.
-
-For instance:
-
-```js run
-new Promise(function(resolve, reject) {
-
-  setTimeout(() => resolve(1), 1000);
-
-}).then(function(result) {
-
-  alert(result); // 1
-
-*!*
-  return new Promise((resolve, reject) => { // (*)
-    setTimeout(() => resolve(result * 2), 1000);
-  });
-*/!*
-
-}).then(function(result) { // (**)
-
-  alert(result); // 2
-
-  return new Promise((resolve, reject) => {
-    setTimeout(() => resolve(result * 2), 1000);
-  });
-
-}).then(function(result) {
-
-  alert(result); // 4
-
-});
-```
-
-Here the first `.then` shows `1` returns `new Promise(…)` in the line `(*)`. After one second it resolves, and the result (the argument of `resolve`, here it's `result*2`) is passed on to handler of the second `.then` in the line `(**)`. It shows `2` and does the same thing.
-
-So the output is again 1 -> 2 -> 4, but now with 1 second delay between `alert` calls.
-
-Returning promises allows us to build chains of asynchronous actions.
-
-## Example: loadScript
-
-Let's use this feature with `loadScript` to load scripts one by one, in sequence:
-
-```js run
-loadScript("/article/promise-chaining/one.js")
-  .then(function(script) {
-    return loadScript("/article/promise-chaining/two.js");
-  })
-  .then(function(script) {
-    return loadScript("/article/promise-chaining/three.js");
-  })
-  .then(function(script) {
-    // use functions declared in scripts
-    // to show that they indeed loaded
-    one();
-    two();
-    three();
-  });
-```
-
-Here each `loadScript` call returns a promise, and the next `.then` runs when it resolves. Then it initiates the loading of the next script. So scripts are loaded one after another.
-
-We can add more asynchronous actions to the chain. Please note that code is still "flat", it grows down, not to the right. There are no signs of "pyramid of doom".
-
-Please note that technically it is also possible to write `.then` directly after each promise, without returning them, like this:
-
-```js run
-loadScript("/article/promise-chaining/one.js").then(function(script1) {
-  loadScript("/article/promise-chaining/two.js").then(function(script2) {
-    loadScript("/article/promise-chaining/three.js").then(function(script3) {
-      // this function has access to variables script1, script2 and script3
-      one();
-      two();
-      three();
-    });
-  });
-});
-```
-
-This code does the same: loads 3 scripts in sequence. But it "grows to the right". So we have the same problem as with callbacks. Use chaining (return promises from `.then`) to evade it.
-
-Sometimes it's ok to write `.then` directly, because the nested function has access to the outer scope (here the most nested callback has access to all variables `scriptX`), but that's an exception rather than a rule.
-
-
-````smart header="Thenables"
-To be precise, `.then` may return an arbitrary "thenable" object, and it will be treated the same way as a promise.
-
-A "thenable" object is any object with a method `.then`.
-
-The idea is that 3rd-party libraries may implement "promise-compatible" objects of their own. They can have extended set of methods, but also be compatible with native promises, because they implement `.then`.
-
-Here's an example of a thenable object:
-
-```js run
-class Thenable {
-  constructor(num) {
-    this.num = num;
-  }
-  then(resolve, reject) {
-    alert(resolve); // function() { native code }
-    // resolve with this.num*2 after the 1 second
-    setTimeout(() => resolve(this.num * 2), 1000); // (**)
-  }
-}
-
-new Promise(resolve => resolve(1))
-  .then(result => {
-    return new Thenable(result); // (*)
-  })
-  .then(alert); // shows 2 after 1000ms
-```
-
-JavaScript checks the object returned by `.then` handler in the line `(*)`: if it has a callable method named `then`, then it calls that method providing native functions `resolve`, `reject` as arguments (similar to executor) and waits until one of them is called. In the example above `resolve(2)` is called after 1 second `(**)`. Then the result is passed further down the chain.
-
-This feature allows to integrate custom objects with promise chains without having to inherit from `Promise`.
-````
-
-
-## Bigger example: fetch
-
-In frontend programming promises are often used for network requests. So let's see an extended example of that.
-
-We'll use the [fetch](mdn:api/WindowOrWorkerGlobalScope/fetch) method to load the information about the user from the remote server. The method is quite complex, it has many optional parameters, but the basic usage is quite simple:
-
-```js
-let promise = fetch(url);
-```
-
-This makes a network request to the `url` and returns a promise. The promise resolves with a `response` object when the remote server responds with headers, but *before the full response is downloaded*.
-
-To read the full response, we should call a method `response.text()`: it returns a promise that resolves  when the full text downloaded from the remote server, with that text as a result.
-
-The code below makes a request to `user.json` and loads its text from the server:
-
-```js run
-fetch('/article/promise-chaining/user.json')
-  // .then below runs when the remote server responds
-  .then(function(response) {
-    // response.text() returns a new promise that resolves with the full response text
-    // when we finish downloading it
-    return response.text();
-  })
-  .then(function(text) {
-    // ...and here's the content of the remote file
-    alert(text); // {"name": "iliakan", isAdmin: true}
-  });
-```
-
-There is also a method `response.json()` that reads the remote data and parses it as JSON. In our case that's even more convenient, so let's switch to it.
-
-We'll also use arrow functions for brevity:
-
-```js run
-// same as above, but response.json() parses the remote content as JSON
-fetch('/article/promise-chaining/user.json')
-  .then(response => response.json())
-  .then(user => alert(user.name)); // iliakan
-```
-
-Now let's do something with the loaded user.
-
-For instance, we can make one more request to github, load the user profile and show the avatar:
-
-```js run
-// Make a request for user.json
-fetch('/article/promise-chaining/user.json')
-  // Load it as json
-  .then(response => response.json())
-  // Make a request to github
-  .then(user => fetch(`https://api.github.com/users/${user.name}`))
-  // Load the response as json
-  .then(response => response.json())
-  // Show the avatar image (githubUser.avatar_url) for 3 seconds (maybe animate it)
-  .then(githubUser => {
-    let img = document.createElement('img');
-    img.src = githubUser.avatar_url;
-    img.className = "promise-avatar-example";
-    document.body.append(img);
-
-    setTimeout(() => img.remove(), 3000); // (*)
-  });
-```
-
-The code works, see comments about the details, but it should be quite self-descriptive. Although, there's a potential problem in it, a typical error of those who begin to use promises.
-
-Look at the line `(*)`: how can we do something *after* the avatar has finished showing and gets removed? For instance, we'd like to show a form for editing that user or something else. As of now, there's no way.
-
-To make the chain extendable, we need to return a promise that resolves when the avatar finishes showing.
-
-Like this:
-
-```js run
-fetch('/article/promise-chaining/user.json')
-  .then(response => response.json())
-  .then(user => fetch(`https://api.github.com/users/${user.name}`))
-  .then(response => response.json())
-*!*
-  .then(githubUser => new Promise(function(resolve, reject) {
-*/!*
-    let img = document.createElement('img');
-    img.src = githubUser.avatar_url;
-    img.className = "promise-avatar-example";
-    document.body.append(img);
-
-    setTimeout(() => {
-      img.remove();
-*!*
-      resolve(githubUser);
-*/!*
-    }, 3000);
-  }))
-  // triggers after 3 seconds
-  .then(githubUser => alert(`Finished showing ${githubUser.name}`));
-```
-
-Now right after `setTimeout` runs `img.remove()`, it calls `resolve(githubUser)`, thus passing the control to the next `.then` in the chain and passing forward the user data.
-
-As a rule, an asynchronous action should always return a promise.
-
-That makes possible to plan actions after it. Even if we don't plan to extend the chain now, we may need it later.
-
-Finally, we can split the code into reusable functions:
-
-```js run
-function loadJson(url) {
-  return fetch(url)
-    .then(response => response.json());
-}
-
-function loadGithubUser(name) {
-  return fetch(`https://api.github.com/users/${name}`)
-    .then(response => response.json());
-}
-
-function showAvatar(githubUser) {
-  return new Promise(function(resolve, reject) {
-    let img = document.createElement('img');
-    img.src = githubUser.avatar_url;
-    img.className = "promise-avatar-example";
-    document.body.append(img);
-
-    setTimeout(() => {
-      img.remove();
-      resolve(githubUser);
-    }, 3000);
-  });
-}
-
-// Use them:
-loadJson('/article/promise-chaining/user.json')
-  .then(user => loadGithubUser(user.name))
-  .then(showAvatar)
-  .then(githubUser => alert(`Finished showing ${githubUser.name}`));
-  // ...
-```
-
-## Error handling
-
-Asynchronous actions may sometimes fail: in case of an error the corresponding promise becomes rejected. For instance, `fetch` fails if the remote server is not available. We can use `.catch` to handle errors (rejections).
-
-Promise chaining is great at that aspect. When a promise rejects, the control jumps to the closest rejection handler down the chain. That's very convenient in practice.
-
-For instance, in the code below the URL is wrong (no such server) and `.catch` handles the error:
-
-```js run
-*!*
-fetch('https://no-such-server.blabla') // rejects
-*/!*
-  .then(response => response.json())
-  .catch(err => alert(err)) // TypeError: failed to fetch (the text may vary)
-```
-
-Or, maybe, everything is all right with the server, but the response is not a valid JSON:
-
-```js run
-fetch('/') // fetch works fine now, the server responds successfully
-*!*
-  .then(response => response.json()) // rejects: the page is HTML, not a valid json
-*/!*
-  .catch(err => alert(err)) // SyntaxError: Unexpected token < in JSON at position 0
-```
-
-
-In the example below we append `.catch` to handle all errors in the avatar-loading-and-showing chain:
-
-```js run
-fetch('/article/promise-chaining/user.json')
-  .then(response => response.json())
-  .then(user => fetch(`https://api.github.com/users/${user.name}`))
-  .then(response => response.json())
-  .then(githubUser => new Promise(function(resolve, reject) {
-    let img = document.createElement('img');
-    img.src = githubUser.avatar_url;
-    img.className = "promise-avatar-example";
-    document.body.append(img);
-
-    setTimeout(() => {
-      img.remove();
-      resolve(githubUser);
-    }, 3000);
-  }))
-  .catch(error => alert(error.message));
-```
-
-Here `.catch` doesn't trigger at all, because there are no errors. But if any of the promises above rejects, then it would execute.
-
-## Implicit try..catch
-
-The code of the executor and promise handlers has an "invisible `try..catch`" around it. If an error happens, it gets caught and treated as a rejection.
-
-For instance, this code:
-
-```js run
-new Promise(function(resolve, reject) {
-*!*
-  throw new Error("Whoops!");
-*/!*
-}).catch(alert); // Error: Whoops!
-```
-
-...Works the same way as this:
-
-```js run
-new Promise(function(resolve, reject) {
-*!*
-  reject(new Error("Whoops!"));
-*/!*  
-}).catch(alert); // Error: Whoops!
-```
-
-The "invisible `try..catch`" around the executor automatically catches the error and treats it as a rejection.
-
-That's so not only in the executor, but in handlers as well. If we `throw` inside `.then` handler, that means a rejected promise, so the control jumps to the nearest error handler.
-
-Here's an example:
-
-```js run
-new Promise(function(resolve, reject) {
-  resolve("ok");
-}).then(function(result) {
-*!*
-  throw new Error("Whoops!"); // rejects the promise
-*/!*
-}).catch(alert); // Error: Whoops!
-```
-
-That's so not only for `throw`, but for any errors, including programming errors as well:
-
-```js run
-new Promise(function(resolve, reject) {
-  resolve("ok");
-}).then(function(result) {
-*!*
-  blabla(); // no such function
-*/!*
-}).catch(alert); // ReferenceError: blabla is not defined
-```
-
-As a side effect, the final `.catch` not only catches explicit rejections, but also occasional errors in the handlers above.
-
-## Rethrowing
-
-As we already noticed, `.catch` behaves like `try..catch`. We may have as many `.then` as we want, and then use a single `.catch` at the end to handle errors in all of them.
-
-In a regular `try..catch` we can analyze the error and maybe rethrow it if can't handle. The same thing is possible for promises. If we `throw` inside `.catch`, then the control goes to the next closest error handler. And if we handle the error and finish normally, then it continues to the closest successful `.then` handler.
-
-In the example below the `.catch` successfully handles the error:
-```js run
-// the execution: catch -> then
-new Promise(function(resolve, reject) {
-
-  throw new Error("Whoops!");
-
-}).catch(function(error) {
-
-  alert("The error is handled, continue normally");
-
-}).then(() => alert("Next successful handler runs"));
-```
-
-Here the `.catch` block finishes normally. So the next successful handler is called. Or it could return something, that would be the same.
-
-...And here the `.catch` block analyzes the error and throws it again:
-
-```js run
-// the execution: catch -> catch -> then
-new Promise(function(resolve, reject) {
-
-  throw new Error("Whoops!");
-
-}).catch(function(error) { // (*)
-
-  if (error instanceof URIError) {
-    // handle it
-  } else {
-    alert("Can't handle such error");
-
-*!*
-    throw error; // throwing this or another error jumps to the next catch
-*/!*
-  }
-
-}).then(function() {
-  /* never runs here */
-}).catch(error => { // (**)
-
-  alert(`The unknown error has occurred: ${error}`);
-  // don't return anything => execution goes the normal way
-
-});
-```
-
-The handler `(*)` catches the error and just can't handle it, because it's not `URIError`, so it throws it again. Then the execution jumps to the next `.catch` down the chain `(**)`.
-
-In the section below we'll see a practical example of rethrowing.
-
-## Fetch error handling example
-
-Let's improve error handling for the user-loading example.
-
-The promise returned by [fetch](mdn:api/WindowOrWorkerGlobalScope/fetch) rejects when it's impossible to make a request. For instance, a remote server is not available, or the URL is malformed. But if the remote server responds with error 404, or even error 500, then it's considered a valid response.
-
-What if the server returns a non-JSON page with error 500 in the line `(*)`? What if there's no such user, and github returns a page with error 404 at `(**)`?
-
-```js run
-fetch('no-such-user.json') // (*)
-  .then(response => response.json())
-  .then(user => fetch(`https://api.github.com/users/${user.name}`)) // (**)
-  .then(response => response.json())
-  .catch(alert); // SyntaxError: Unexpected token < in JSON at position 0
-  // ...
-```
-
-
-As of now, the code tries to load the response as JSON no matter what and dies with a syntax error. You can see that by running the example above, as the file `no-such-user.json` doesn't exist.
-
-That's not good, because the error just falls through the chain, without details: what failed and where.
-
-So let's add one more step: we should check the `response.status` property that has HTTP status, and if it's not 200, then throw an error.
-
-```js run
-class HttpError extends Error { // (1)
-  constructor(response) {
-    super(`${response.status} for ${response.url}`);
-    this.name = 'HttpError';
-    this.response = response;
-  }
-}
-
-function loadJson(url) { // (2)
-  return fetch(url)
-    .then(response => {
-      if (response.status == 200) {
-        return response.json();
-      } else {
-        throw new HttpError(response);
-      }
-    })
-}
-
-loadJson('no-such-user.json') // (3)
-  .catch(alert); // HttpError: 404 for .../no-such-user.json
-```
-
-1. We make a custom class for HTTP Errors to distinguish them from other types of errors. Besides, the new class has a constructor that accepts the `response` object and saves it in the error. So error-handling code will be able to access it.
-2. Then we put together the requesting and error-handling code into a function that fetches the `url` *and* treats any non-200 status as an error. That's convenient, because we often need such logic.
-3. Now `alert` shows better message.
-
-The great thing about having our own class for errors is that we can easily check for it in error-handling code.
-
-For instance, we can make a request, and then if we get 404 -- ask the user to modify the information.
-
-The code below loads a user with the given name from github. If there's no such user, then it asks for the correct name:
-
-```js run
-function demoGithubUser() {
-  let name = prompt("Enter a name?", "iliakan");
-
-  return loadJson(`https://api.github.com/users/${name}`)
-    .then(user => {
-      alert(`Full name: ${user.name}.`); // (1)
-      return user;
-    })
-    .catch(err => {
-*!*
-      if (err instanceof HttpError && err.response.status == 404) { // (2)
-*/!*
-        alert("No such user, please reenter.");
-        return demoGithubUser();
-      } else {
-        throw err;
-      }
-    });
-}
-
-demoGithubUser();
-```
-
-Here:
-
-1. If `loadJson` returns a valid user object, then the name is shown `(1)`, and the user is returned, so that we can add more user-related actions to the chain. In that case the `.catch` below is ignored, everything's very simple and fine.
-2. Otherwise, in case of an error, we check it in the line `(2)`. Only if it's indeed the HTTP error, and the status is 404 (Not found), we ask the user to reenter. For other errors -- we don't know how to handle, so we just rethrow them.
-
-## Unhandled rejections
-
-What happens when an error is not handled? For instance, after the rethrow as in the example above. Or if we forget to append an error handler to the end of the chain, like here:
-
-```js untrusted run refresh
-new Promise(function() {
-  noSuchFunction(); // Error here (no such function)
-}); // no .catch attached
-```
-
-Or here:
-
-```js untrusted run refresh
-// a chain of promises without .catch at the end
-new Promise(function() {
-  throw new Error("Whoops!");
-}).then(function() {
-  // ...something...
-}).then(function() {
-  // ...something else...
-}).then(function() {
-  // ...but no catch after it!
-});
-```
-
-In case of an error, the promise state becomes "rejected", and the execution should jump to the closest rejection handler. But there is no such handler in the examples above. So the error gets "stuck".
-
-In practice, that's usually because of the bad code. Indeed, how come there's no error handling?
-
-Most JavaScript engines track such situations and generate a global error in that case. We can see it in the console.
-
-In the browser we can catch it using the event `unhandledrejection`:
-
-```js run
-*!*
-window.addEventListener('unhandledrejection', function(event) {
-  // the event object has two special properties:
-  alert(event.promise); // [object Promise] - the promise that generated the error
-  alert(event.reason); // Error: Whoops! - the unhandled error object
-});
-*/!*
-
-new Promise(function() {
-  throw new Error("Whoops!");
-}); // no catch to handle the error
-```
-
-The event is the part of the [HTML standard](https://html.spec.whatwg.org/multipage/webappapis.html#unhandled-promise-rejections). Now if an error occurs, and there's no `.catch`, the `unhandledrejection` handler triggers: the `event` object has the information about the error, so we can do something with it.
-
-Usually such errors are unrecoverable, so our best way out is to inform the user about the problem and probably report about the incident to the server.
-
-In non-browser environments like Node.JS there are other similar ways to track unhandled errors.
-
-## Summary
-
-To summarize, `.then/catch(handler)` returns a new promise that changes depending on what handler does:
-
-1. If it returns a value or finishes without a `return` (same as `return undefined`), then the new promise becomes resolved, and the closest resolve handler (the first argument of `.then`) is called with that value.
-2. If it throws an error, then the new promise becomes rejected, and the closest rejection handler (second argument of `.then` or `.catch`) is called with it.
-3. If it returns a promise, then JavaScript waits until it settles and then acts on its outcome the same way.
-
-The picture of how the promise returned by `.then/catch` changes:
-
-![](promise-handler-variants.png)
-
-The smaller picture of how handlers are called:
-
-![](promise-handler-variants-2.png)
-
-In the examples of error handling above the `.catch` was always the last in the chain. In practice though, not every promise chain has a `.catch`. Just like regular code is not always wrapped in `try..catch`.
-
-We should place `.catch` exactly in the places where we want to handle errors and know how to handle them. Using custom error classes can help to analyze errors and rethrow those that we can't handle.
-
-For errors that fall outside of our scope we should have the `unhandledrejection` event handler (for browsers, and analogs for other environments). Such unknown errors are usually unrecoverable, so all we should do is to inform the user and probably report to our server about the incident.
diff --git a/6-async/03-promise-chaining/promise-handler-variants-2.png b/6-async/03-promise-chaining/promise-handler-variants-2.png
deleted file mode 100644
index 1b4eff7af..000000000
Binary files a/6-async/03-promise-chaining/promise-handler-variants-2.png and /dev/null differ
diff --git a/6-async/03-promise-chaining/promise-handler-variants-2@2x.png b/6-async/03-promise-chaining/promise-handler-variants-2@2x.png
deleted file mode 100644
index 241733fb6..000000000
Binary files a/6-async/03-promise-chaining/promise-handler-variants-2@2x.png and /dev/null differ
diff --git a/6-async/03-promise-chaining/promise-handler-variants.png b/6-async/03-promise-chaining/promise-handler-variants.png
deleted file mode 100644
index 541c18eb2..000000000
Binary files a/6-async/03-promise-chaining/promise-handler-variants.png and /dev/null differ
diff --git a/6-async/03-promise-chaining/promise-handler-variants@2x.png b/6-async/03-promise-chaining/promise-handler-variants@2x.png
deleted file mode 100644
index 3a2f6b1d8..000000000
Binary files a/6-async/03-promise-chaining/promise-handler-variants@2x.png and /dev/null differ
diff --git a/6-async/03-promise-chaining/promise-then-chain.png b/6-async/03-promise-chaining/promise-then-chain.png
deleted file mode 100644
index 7cd1baa93..000000000
Binary files a/6-async/03-promise-chaining/promise-then-chain.png and /dev/null differ
diff --git a/6-async/03-promise-chaining/promise-then-chain@2x.png b/6-async/03-promise-chaining/promise-then-chain@2x.png
deleted file mode 100644
index 3d981342b..000000000
Binary files a/6-async/03-promise-chaining/promise-then-chain@2x.png and /dev/null differ
diff --git a/6-async/03-promise-chaining/promise-then-many.png b/6-async/03-promise-chaining/promise-then-many.png
deleted file mode 100644
index 199867f84..000000000
Binary files a/6-async/03-promise-chaining/promise-then-many.png and /dev/null differ
diff --git a/6-async/03-promise-chaining/promise-then-many@2x.png b/6-async/03-promise-chaining/promise-then-many@2x.png
deleted file mode 100644
index 2e7847eb2..000000000
Binary files a/6-async/03-promise-chaining/promise-then-many@2x.png and /dev/null differ
diff --git a/6-data-storage/01-cookie/article.md b/6-data-storage/01-cookie/article.md
new file mode 100644
index 000000000..e6322fd6c
--- /dev/null
+++ b/6-data-storage/01-cookie/article.md
@@ -0,0 +1,426 @@
+# Cookies, document.cookie
+
+Cookies are small strings of data that are stored directly in the browser. They are a part of HTTP protocol, defined by [RFC 6265](https://tools.ietf.org/html/rfc6265) specification.
+
+Most of the time, cookies are set by a web server. Then they are automatically added to every request to the same domain.
+
+One of the most widespread use cases is authentication:
+
+1. Upon sign in, the server uses `Set-Cookie` HTTP-header in the response to set a cookie with "session identifier".
+2. Next time when the request is set to the same domain, the browser sends the over the net using `Cookie` HTTP-header.
+3. So the server knows who made the request.
+
+We can also access cookies from the browser, using `document.cookie` property.
+
+There are many tricky things about cookies and their options. In this chapter we'll cover them in detail.
+
+## Reading from document.cookie
+
+```online
+Do you have any cookies on this site? Let's see:
+```
+
+```offline
+Assuming you're on a website, it's possible to see the cookies, like this:
+```
+
+```js run
+// At javascript.info, we use Google Analytics for statistics,
+// so there should be some cookies
+alert( document.cookie ); // cookie1=value1; cookie2=value2;...
+```
+
+
+The value of `document.cookie` consists of `name=value` pairs, delimited by `; `. Each one is a separate cookie.
+
+To find a particular cookie, we can split `document.cookie` by `; `, and then find the right name. We can use either a regular expression or array functions to do that.
+
+We leave it as an exercise for the reader. Also, at the end of the chapter you'll find helper functions to manipulate cookies.
+
+## Writing to document.cookie
+
+We can write to `document.cookie`. But it's not a data property, it's an accessor.
+
+**A write operation to `document.cookie` passes through the browser that updates cookies mentioned in it, but doesn't touch other cookies.**
+
+For instance, this call sets a cookie with the name `user` and value `John`:
+
+```js run
+document.cookie = "user=John"; // update only cookie named 'user'
+alert(document.cookie); // show all cookies
+```
+
+If you run it, then probably you'll see multiple cookies. That's because `document.cookie=` operation does not overwrite all cookies. It only sets the mentioned cookie `user`.
+
+Technically, name and value can have any characters, but to keep the formatting valid they should be escaped using a built-in `encodeURIComponent` function:
+
+```js run
+// special values, need encoding
+let name = "my name";
+let value = "John Smith"
+
+// encodes the cookie as my%20name=John%20Smith
+document.cookie = encodeURIComponent(name) + '=' + encodeURIComponent(value);
+
+alert(document.cookie); // ...; my%20name=John%20Smith
+```
+
+
+```warn header="Limitations"
+There are few limitations:
+- The `name=value` pair, after `encodeURIComponent`, should not exceed 4kb. So we can't store anything huge in a cookie.
+- The total number of cookies per domain is limited to around 20+, the exact limit depends on a browser.
+```
+
+Cookies have several options, many of them are important and should be set.
+
+The options are listed after `key=value`, delimited by `;`, like this:
+
+```js run
+document.cookie = "user=John; path=/; expires=Tue, 19 Jan 2038 03:14:07 GMT"
+```
+
+## path
+
+- **`path=/mypath`**
+
+The url path prefix, where the cookie is accessible. Must be absolute. By default, it's the current path.
+
+If a cookie is set with `path=/admin`, it's visible at pages `/admin` and `/admin/something`, but not at `/home` or `/adminpage`.
+
+Usually, we set `path=/` to make the cookie accessible from all website pages.
+
+## domain
+
+- **`domain=site.com`**
+
+A domain where the cookie is accessible. In practice though, there are limitations. We can't set any domain.
+
+By default, a cookie is accessible only at the domain that set it. So, if the cookie was set by `site.com`, we won't get it `other.com`.
+
+...But what's more tricky, we also won't get the cookie at a subdomain `forum.site.com`!
+
+```js
+// at site.com
+document.cookie = "user=John"
+
+// at forum.site.com
+alert(document.cookie); // no user
+```
+
+**There's no way to let a cookie be accessible from another 2nd-level domain, so `other.com` will never receive a cookie set at `site.com`.**
+
+It's a safety restriction, to allow us to store sensitive data in cookies.
+
+...But if we'd like to grant access to subdomains like `forum.site.com`, that's possible. We  should explicitly set `domain` option to the root domain: `domain=site.com`:
+
+```js
+// at site.com, make the cookie accessible on any subdomain:
+document.cookie = "user=John; domain=site.com"
+
+// at forum.site.com
+alert(document.cookie); // with user
+```
+
+For historical reasons, `domain=.site.com` (a dot at the start) also works this way, it might better to add the dot to support very old browsers.
+
+So, `domain` option allows to make a cookie accessible at subdomains.
+
+## expires, max-age
+
+By default, if a cookie doesn't have one of these options, it disappears when the browser is closed. Such cookies are called "session cookies"
+
+To let cookies survive browser close, we can set either `expires` or `max-age` option.
+
+- **`expires=Tue, 19 Jan 2038 03:14:07 GMT`**
+
+Cookie expiration date, when the browser will delete it automatically.
+
+The date must be exactly in this format, in GMT timezone. We can use `date.toUTCString` to get it. For instance, we can set the cookie to expire in 1 day:
+
+```js
+// +1 day from now
+let date = new Date(Date.now() + 86400e3);
+date = date.toUTCString();
+document.cookie = "user=John; expires=" + date;
+```
+
+If we set `expires` to a date in the past, the cookie is deleted.
+
+-  **`max-age=3600`**
+
+An alternative to `expires`, specifies the cookie expiration in seconds from the current moment.
+
+If zero or negative, then the cookie is deleted:
+
+```js
+// cookie will die +1 hour from now
+document.cookie = "user=John; max-age=3600";
+
+// delete cookie (let it expire right now)
+document.cookie = "user=John; max-age=0";
+```  
+
+## secure
+
+- **`secure`**
+
+The cookie should be transferred only over HTTPS.
+
+**By default, if we set a cookie at `http://site.com`, then it also appears at `https://site.com` and vice versa.**
+
+That is, cookies are domain-based, they do not distinguish between the protocols.
+
+With this option, if a cookie is set by `https://site.com`, then it doesn't appear when the same site is accessed by HTTP, as `http://site.com`. So if a cookie has sensitive content that should never be sent over unencrypted HTTP, then the flag is the right thing.
+
+```js
+// assuming we're on https:// now
+// set the cookie secure (only accessible if over HTTPS)
+document.cookie = "user=John; secure";
+```  
+
+## samesite
+
+That's another security option, to protect from so-called XSRF (cross-site request forgery) attacks.
+
+To understand when it's useful, let's introduce the following attack scenario.
+
+### XSRF attack
+
+Imagine, you are logged into the site `bank.com`. That is: you have an authentication cookie from that site. Your browser sends it to `bank.com` with every request, so that it recognizes you and performs all sensitive financial operations.
+
+Now, while browsing the web in another window, you occasionally come to another site `evil.com`, that automatically submits a form `<form action="https://bank.com/pay">` to `bank.com` with input fields that initiate a transaction to the hacker's account.
+
+The form is submitted from `evil.com` directly to the bank site, and your cookie is also sent, just because it's sent every time you visit `bank.com`. So the bank recognizes you and actually performs the payment.
+
+![](cookie-xsrf.png)
+
+That's called a cross-site request forgery (or XSRF) attack.
+
+Real banks are protected from it of course. All forms generated by `bank.com` have a special field, so called "xsrf protection token", that an evil page can't neither generate, nor somehow extract from a remote page (it can submit a form there, but can't get the data back).
+
+But that takes time to implement: we need to ensure that every form has the token field, and we must also check all requests.
+
+### Enter cookie samesite option
+
+The cookie `samesite` option provides another way to protect from such attacks, that (in theory) should not require "xsrf protection tokens".
+
+It has two possible values:
+
+- **`samesite=strict` (same as `samesite` without value)**
+
+A cookie with `samesite=strict` is never sent if the user comes from outside the site.
+
+In other words, whether a user follows a link from their mail or submits a form from `evil.com`, or does any operation that originates from another domain, the cookie is not sent.
+
+If authentication cookies have `samesite` option, then XSRF attack has no chances to succeed, because a submission from `evil.com` comes without cookies. So `bank.com` will not recognize the user and will not proceed with the payment.
+
+The protection is quite reliable. Only operations that come from `bank.com` will send the `samesite` cookie.
+
+Although, there's a small inconvenience.
+
+When a user follows a legitimate link to `bank.com`, like from their own notes, they'll be surprised that `bank.com` does not recognize them. Indeed, `samesite=strict` cookies are not sent in that case.
+
+We could work around that by using two cookies: one for "general recognition", only for the purposes of saying: "Hello, John", and the other one for data-changing operations with `samesite=strict`. Then a person coming from outside of the site will see a welcome, but payments must be initiated from the bank website.
+
+- **`samesite=lax`**
+
+A more relaxed approach that also protects from XSRF and doesn't break user experience.
+
+Lax mode, just like `strict`, forbids the browser to send cookies when coming from outside the site, but adds an exception.
+
+A `samesite=lax` cookie is sent if both of these conditions are true:
+1. The HTTP method is "safe" (e.g. GET, but not POST).
+
+    The full list safe of HTTP methods is in the [RFC7231 specification](https://tools.ietf.org/html/rfc7231). Basically, these are the methods that should be used for reading, but not writing the data. They must not perform any data-changing operations. Following a link is always GET, the safe method.
+
+2. The operation performs top-level navigation (changes URL in the browser address bar).
+
+    That's usually true, but if the navigation is performed in an `<iframe>`, then it's not top-level. Also, AJAX requests do not perform any navigation, hence they don't fit.
+
+So, what `samesite=lax` does is basically allows a most common "go to URL" operation to have cookies. E.g. opening a website link from notes satisfies these conditions.
+
+But anything more complicated, like AJAX request from another site or a form submittion loses cookies.
+
+If that's fine for you, then adding `samesite=lax` will probably not break the user experience and add protection.
+
+Overall, `samesite` is a great option, but it has an important drawback:
+- `samesite` is ignored (not supported) by old browsers, year 2017 or so.
+
+**So if we solely rely on `samesite` to provide protection, then old browsers will be vulnerable.**
+
+But we surely can use `samesite` together with other protection measures, like xsrf tokens, to add an additional layer of defence and then, in the future, when old browsers die out, we'll probably be able to drop xsrf tokens.
+
+## httpOnly
+
+This option has nothing to do with JavaScript, but we have to mention it for completeness.
+
+The web-server uses `Set-Cookie` header to set a cookie. And it may set the `httpOnly` option.
+
+This option forbids any JavaScript access to the cookie. We can't see such cookie or manipulate it using `document.cookie`.
+
+That's used as a precaution measure, to protect from certain attacks when a hacker injects his own JavaScript code into a page and waits for a user to visit that page. That shouldn't be possible at all, a hacker should not be able to inject their code into our site, but there may be bugs that let hackers do it.
+
+
+Normally, if such thing happens, and a user visits a web-page with hacker's code, then that code executes and gains access to `document.cookie` with user cookies containing authentication information. That's bad.
+
+But if a cookie is `httpOnly`, then `document.cookie` doesn't see it, so it is protected.
+
+## Appendix: Cookie functions
+
+Here's a small set of functions to work with cookies, more convenient than a manual modification of `document.cookie`.
+
+There exist many cookie libraries for that, so these are for demo purposes. Fully working though.
+
+
+### getCookie(name)
+
+The shortest way to access cookie is to use a [regular expression](info:regular-expressions).
+
+The function `getCookie(name)` returns the cookie with the given `name`:
+
+```js
+// returns the cookie with the given name,
+// or undefined if not found
+function getCookie(name) {
+  let matches = document.cookie.match(new RegExp(
+    "(?:^|; )" + name.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, '\\$1') + "=([^;]*)"
+  ));
+  return matches ? decodeURIComponent(matches[1]) : undefined;
+}
+```
+
+Here `new RegExp` is generated dynamically, to match `; name=<value>`.
+
+Please note that a cookie value is encoded, so `getCookie` uses a built-in `decodeURIComponent` function to decode it.
+
+### setCookie(name, value, options)
+
+Sets the cookie `name` to the given `value` with `path=/` by default (can be modified to add other defaults):
+
+```js run
+function setCookie(name, value, options = {}) {
+
+  options = {
+    path: '/',
+    // add other defaults here if necessary
+    ...options
+  };
+
+  if (options.expires.toUTCString) {
+    options.expires = options.expires.toUTCString();
+  }
+
+  let updatedCookie = encodeURIComponent(name) + "=" + encodeURIComponent(value);
+
+  for (let optionKey in options) {
+    updatedCookie += "; " + optionKey;
+    let optionValue = options[optionKey];
+    if (optionValue !== true) {
+      updatedCookie += "=" + optionValue;
+    }
+  }
+
+  document.cookie = updatedCookie;
+}
+
+// Example of use:
+setCookie('user', 'John', {secure: true, 'max-age': 3600});
+```
+
+### deleteCookie(name)
+
+To delete a cookie, we can call it with a negative expiration date:
+
+```js
+function deleteCookie(name) {
+  setCookie(name, "", {
+    'max-age': -1
+  })
+}
+```
+
+```warn header="Updating or deleting must use same path and domain"
+Please note: when we update or delete a cookie, we should use exactly the same path and domain options as when we set it.
+```
+
+Together: [cookie.js](cookie.js).
+
+
+## Appendix: Third-party cookies
+
+A cookie is called "third-party" if it's placed by domain other than the user is visiting.
+
+For instance:
+1. A page at `site.com` loads a banner from another site: `<img src="https://ads.com/banner.png">`.
+2. Along with the banner, the remote server at `ads.com` may set `Set-Cookie` header with cookie like `id=1234`. Such cookie originates from `ads.com` domain, and will only be visible at `ads.com`:
+
+    ![](cookie-third-party.png)
+
+3. Next time when `ads.com` is accessed, the remote server gets the `id` cookie and recognizes the user:
+
+    ![](cookie-third-party-2.png)
+
+4. What's even more important, when the users moves from `site.com` to another site `other.com` that also has a banner, then `ads.com` gets the cookie, as it belongs to `ads.com`, thus recognizing the visitor and tracking him as he moves between sites:
+
+    ![](cookie-third-party-3.png)
+
+
+Third-party cookies are traditionally used for tracking and ads services, due to their nature. They are bound to the originating domain, so `ads.com` can track the same user between different sites, if they all access it.
+
+Naturally, some people don't like being tracked, so browsers allow to disable such cookies.
+
+Also, some modern browsers employ special policies for such cookies:
+- Safari does not allow third-party cookies at all.
+- Firefox comes with a "black list" of third-party domains where it blocks third-party cookies.
+
+
+```smart
+If we load a script from a third-party domain, like `<script src="https://google-analytics.com/analytics.js">`, and that script uses `document.cookie` to set a cookie, then such cookie is not third-party.
+
+If a script sets a cookie, then no matter where the script came from -- it belongs to the domain of the current webpage.
+```
+
+## Appendix: GDPR
+
+This topic is not related to JavaScript at all, just something to keep in mind when setting cookies.
+
+There's a legislation in Europe called GDPR, that enforces a set of rules for websites to respect users' privacy. And one of such rules is to require an explicit permission for tracking cookies from a user.
+
+Please note, that's only about tracking/identifying cookies.
+
+So, if we set a cookie that just saves some information, but neither tracks nor identifies the user, then we are free to do it.
+
+But if we are going to set a cookie with an authentication session or a tracking id, then a user must allow that.
+
+Websites generally have two variants of following GDPR. You must have seen them both already in the web:
+
+1. If a website wants to set tracking cookies only for authenticated users.
+
+    To do so, the registration form should have a checkbox like "accept the privacy policy", the user must check it, and then the website is free to set auth cookies.
+
+2. If a website wants to set tracking cookies for everyone.
+
+    To do so legally, a website shows a modal "splash screen" for newcomers, and require them to agree for cookies. Then the website can set them and let people see the content. That can be disturbing for new visitors though. No one likes to see "must-click" modal splash screens instead of the content. But GDPR requires an explicit agreement.
+
+
+GDPR is not only about cookies, it's about other privacy-related issues too, but that's too much beyond our scope.
+
+
+## Summary
+
+`document.cookie` provides access to cookies
+- write operations modify only cookies mentioned in it.
+- name/value must be encoded.
+- one cookie up to 4kb, 20+ cookies per site (depends on a browser).
+
+Cookie options:
+- `path=/`, by default current path, makes the cookie visible only under that path.
+- `domain=site.com`, by default a cookie is visible on current domain only, if set explicitly to the domain, makes the cookie visible on subdomains.
+- `expires` or `max-age` sets cookie expiration time, without them the cookie dies when the browser is closed.
+- `secure` makes the cookie HTTPS-only.
+- `samesite` forbids the browser to send the cookie with requests coming from outside the site, helps to prevent XSRF attacks.
+
+Additionally:
+- Third-party cookies may be forbidden by the browser, e.g. Safari does that by default.
+- When setting a tracking cookie for EU citizens, GDPR requires to ask for permission.
diff --git a/6-data-storage/01-cookie/cookie-third-party-2.png b/6-data-storage/01-cookie/cookie-third-party-2.png
new file mode 100644
index 000000000..7e8b13fd8
Binary files /dev/null and b/6-data-storage/01-cookie/cookie-third-party-2.png differ
diff --git a/6-data-storage/01-cookie/cookie-third-party-2@2x.png b/6-data-storage/01-cookie/cookie-third-party-2@2x.png
new file mode 100644
index 000000000..461f68871
Binary files /dev/null and b/6-data-storage/01-cookie/cookie-third-party-2@2x.png differ
diff --git a/6-data-storage/01-cookie/cookie-third-party-3.png b/6-data-storage/01-cookie/cookie-third-party-3.png
new file mode 100644
index 000000000..fa10aa2a7
Binary files /dev/null and b/6-data-storage/01-cookie/cookie-third-party-3.png differ
diff --git a/6-data-storage/01-cookie/cookie-third-party-3@2x.png b/6-data-storage/01-cookie/cookie-third-party-3@2x.png
new file mode 100644
index 000000000..d7a583469
Binary files /dev/null and b/6-data-storage/01-cookie/cookie-third-party-3@2x.png differ
diff --git a/6-data-storage/01-cookie/cookie-third-party.png b/6-data-storage/01-cookie/cookie-third-party.png
new file mode 100644
index 000000000..907217c06
Binary files /dev/null and b/6-data-storage/01-cookie/cookie-third-party.png differ
diff --git a/6-data-storage/01-cookie/cookie-third-party@2x.png b/6-data-storage/01-cookie/cookie-third-party@2x.png
new file mode 100644
index 000000000..c2d98ae61
Binary files /dev/null and b/6-data-storage/01-cookie/cookie-third-party@2x.png differ
diff --git a/6-data-storage/01-cookie/cookie-xsrf.png b/6-data-storage/01-cookie/cookie-xsrf.png
new file mode 100644
index 000000000..92447bb17
Binary files /dev/null and b/6-data-storage/01-cookie/cookie-xsrf.png differ
diff --git a/6-data-storage/01-cookie/cookie-xsrf@2x.png b/6-data-storage/01-cookie/cookie-xsrf@2x.png
new file mode 100644
index 000000000..d20e5fdde
Binary files /dev/null and b/6-data-storage/01-cookie/cookie-xsrf@2x.png differ
diff --git a/6-data-storage/01-cookie/cookie.js b/6-data-storage/01-cookie/cookie.js
new file mode 100644
index 000000000..7d8eebf3e
--- /dev/null
+++ b/6-data-storage/01-cookie/cookie.js
@@ -0,0 +1,38 @@
+function getCookie(name) {
+  let matches = document.cookie.match(new RegExp(
+    "(?:^|; )" + name.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, '\\$1') + "=([^;]*)"
+  ));
+  return matches ? decodeURIComponent(matches[1]) : undefined;
+}
+
+function setCookie(name, value, options = {}) {
+
+  options = {
+    path: '/',
+    // add other defaults here if necessary
+    ...options
+  };
+
+  if (options.expires.toUTCString) {
+    options.expires = options.expires.toUTCString();
+  }
+
+  let updatedCookie = encodeURIComponent(name) + "=" + encodeURIComponent(value);
+
+  for (let optionKey in options) {
+    updatedCookie += "; " + optionKey;
+    let optionValue = options[optionKey];
+    if (optionValue !== true) {
+      updatedCookie += "=" + optionValue;
+    }
+  }
+
+  document.cookie = updatedCookie;
+}
+
+
+function deleteCookie(name) {
+  setCookie(name, "", {
+    'max-age': -1
+  })
+}
diff --git a/6-data-storage/01-cookie/safari-nocookie.png b/6-data-storage/01-cookie/safari-nocookie.png
new file mode 100644
index 000000000..1a4fb8685
Binary files /dev/null and b/6-data-storage/01-cookie/safari-nocookie.png differ
diff --git a/6-data-storage/01-cookie/safari-nocookie@2x.png b/6-data-storage/01-cookie/safari-nocookie@2x.png
new file mode 100644
index 000000000..6c3f9d824
Binary files /dev/null and b/6-data-storage/01-cookie/safari-nocookie@2x.png differ
diff --git a/6-data-storage/02-localstorage/1-form-autosave/solution.md b/6-data-storage/02-localstorage/1-form-autosave/solution.md
new file mode 100644
index 000000000..8b1378917
--- /dev/null
+++ b/6-data-storage/02-localstorage/1-form-autosave/solution.md
@@ -0,0 +1 @@
+
diff --git a/6-data-storage/02-localstorage/1-form-autosave/solution.view/index.html b/6-data-storage/02-localstorage/1-form-autosave/solution.view/index.html
new file mode 100644
index 000000000..7be198927
--- /dev/null
+++ b/6-data-storage/02-localstorage/1-form-autosave/solution.view/index.html
@@ -0,0 +1,10 @@
+<!doctype html>
+<textarea style="width:200px; height: 60px;" id="area" placeholder="Write here"></textarea>
+<br>
+<button onclick="localStorage.removeItem('area');area.value=''">Clear</button>
+<script>
+    area.value = localStorage.getItem('area');
+    area.oninput = () => {
+      localStorage.setItem('area', area.value)
+    };
+</script>
diff --git a/6-data-storage/02-localstorage/1-form-autosave/source.view/index.html b/6-data-storage/02-localstorage/1-form-autosave/source.view/index.html
new file mode 100644
index 000000000..95a741758
--- /dev/null
+++ b/6-data-storage/02-localstorage/1-form-autosave/source.view/index.html
@@ -0,0 +1,2 @@
+<!doctype html>
+<textarea style="width:200px; height: 60px;" id="area"></textarea>
diff --git a/6-data-storage/02-localstorage/1-form-autosave/task.md b/6-data-storage/02-localstorage/1-form-autosave/task.md
new file mode 100644
index 000000000..b2e0a4222
--- /dev/null
+++ b/6-data-storage/02-localstorage/1-form-autosave/task.md
@@ -0,0 +1,10 @@
+
+# Autosave a form field
+
+Create a `textarea` field that "autosaves" its value on every change.
+
+So, if the user occasionally closes the page, and opens it again, he'll find his unfinished input at place.
+
+Like this:
+
+[iframe src="solution" height=120]
diff --git a/6-data-storage/02-localstorage/article.md b/6-data-storage/02-localstorage/article.md
new file mode 100644
index 000000000..41a895b05
--- /dev/null
+++ b/6-data-storage/02-localstorage/article.md
@@ -0,0 +1,247 @@
+# LocalStorage, sessionStorage
+
+Web storage objects `localStorage` and `sessionStorage` allow to save key/value pairs in the browser.
+
+What's interesting about them is that the data survives a page refresh (for `sessionStorage`) and even a full browser restart (for `localStorage`). We'll see that very soon.
+
+We already have cookies. Why additional objects?
+
+- Unlike cookies, web storage objects are not sent to server with each request. Because of that, we can store much more. Most browsers allow at least 2 megabytes of data (or more) and have settings to configure that.
+- The server can't manipulate storage objects via HTTP headers, everything's done in JavaScript.
+- The storage is bound to the origin (domain/protocol/port triplet). That is, different protocols or subdomains infer different storage objects, they can't access data from each other.
+
+Both storage objects provide same methods and properties:
+
+- `setItem(key, value)` -- store key/value pair.
+- `getItem(key)` -- get the value by key.
+- `removeItem(key)` -- remove the key with its value.
+- `clear()` -- delete everything.
+- `key(index)` -- get the key on a given position.
+- `length` -- the number of stored items.
+
+Let's see how it works.
+
+## localStorage demo
+
+The main features of `localStorage` are:
+
+- Shared between all tabs and windows from the same origin.
+- The data does not expire. It remains after the browser restart and even OS reboot.
+
+For instance, if you run this code...
+
+```js run
+localStorage.setItem('test', 1);
+```
+
+...And close/open the browser or just open the same page in a different window, then you can get it like this:
+
+```js run
+alert( localStorage.getItem('test') ); // 1
+```
+
+We only have to be on the same domain/port/protocol, the url path can be different.
+
+The `localStorage` is shared, so if we set the data in one window, the change becomes visible in the other one.
+
+## Object-like access
+
+We can also use a plain object way of getting/setting keys, like this:
+
+```js run
+// set key
+localStorage.test = 2;
+
+// get key
+alert( localStorage.test ); // 2
+
+// remove key
+delete localStorage.test;
+```
+
+That's allowed for historical reasons, and mostly works, but generally not recommended for two reasons:
+
+1. If the key is user-generated, it can be anything, like `length` or `toString`, or another built-in method of `localStorage`. In that case `getItem/setItem` work fine, while object-like access fails:
+    ```js run
+    let key = 'length';
+    localStorage[key] = 5; // Error, can't assign length
+    ```
+
+2. There's a `storage` event, it triggers when we modify the data. That event does not happen for object-like access. We'll see that later in this chapter.
+
+## Looping over keys
+
+Methods provide get/set/remove functionality. But how to get all the keys?
+
+Unfortunately, storage objects are not iterable.
+
+One way is to use "array-like" iteration:
+
+```js run
+for(let i=0; i<localStorage.length; i++) {
+  let key = localStorage.key(i);
+  alert(`${key}: ${localStorage.getItem(key)}`);
+}
+```
+
+Another way is to use object-specific `for key in localStorage` loop.
+
+That iterates over keys, but also outputs few built-in fields that we don't need:
+
+```js run
+// bad try
+for(let key in localStorage) {
+  alert(key); // shows getItem, setItem and other built-in stuff
+}
+```
+
+...So we need either to filter fields from the prototype with `hasOwnProperty` check:
+
+```js run
+for(let key in localStorage) {
+  if (!localStorage.hasOwnProperty(key)) {
+    continue; // skip keys like "setItem", "getItem" etc
+  }
+  alert(`${key}: ${localStorage.getItem(key)}`);
+}
+```
+
+...Or just get the "own" keys with `Object.keys` and then loop over them if needed:
+
+```js run
+let keys = Object.keys(localStorage);
+for(let key of keys) {
+  alert(`${key}: ${localStorage.getItem(key)}`);
+}
+```
+
+The latter works, because `Object.keys` only returns the keys that belong to the object, ignoring the prototype.
+
+
+## Strings only
+
+Please note that both key and value must be strings.
+
+If we any other type, like a number, or an object, it gets converted to string automatically:
+
+```js run
+sessionStorage.user = {name: "John"};
+alert(sessionStorage.user); // [object Object]
+```
+
+We can use `JSON` to store objects though:
+
+```js run
+sessionStorage.user = JSON.stringify({name: "John"});
+
+// sometime later
+let user = JSON.parse( sessionStorage.user );
+alert( user.name ); // John
+```
+
+Also it is possible to stringify the whole storage object, e.g. for debugging purposes:
+
+```js run
+// added formatting options to JSON.stringify to make the object look nicer
+alert( JSON.stringify(localStorage, null, 2) );
+```
+
+
+## sessionStorage
+
+The `sessionStorage` object is used much less often than `localStorage`.
+
+Properties and methods are the same, but it's much more limited:
+
+- The `sessionStorage` exists only within the current browser tab.
+  - Another tab with the same page will have a different storage.
+  - But it is shared between iframes in the tab (assuming they come from the same origin).
+- The data survives page refresh, but not closing/opening the tab.
+
+Let's see that in action.
+
+Run this code...
+
+```js run
+sessionStorage.setItem('test', 1);
+```
+
+...Then refresh the page. Now you can still get the data:
+
+```js run
+alert( sessionStorage.getItem('test') ); // after refresh: 1
+```
+
+...But if you open the same page in another tab, and try again there, the code above returns `null`, meaning "nothing found".
+
+That's exactly because `sessionStorage` is bound not only to the origin, but also to the browser tab. For that reason, `sessionStorage` is used sparingly.
+
+## Storage event
+
+When the data gets updated in `localStorage` or `sessionStorage`, [storage](https://www.w3.org/TR/webstorage/#the-storage-event) event triggers, with properties:
+
+- `key` – the key that was changed (null if `.clear()` is called).
+- `oldValue` – the old value (`null` if the key is newly added).
+- `newValue` – the new value (`null` if the key is removed).
+- `url` – the url of the document where the update happened.
+- `storageArea` – either `localStorage` or `sessionStorage` object where the update happened.
+
+The important thing is: the event triggers on all `window` objects where the storage is accessible, except the one that caused it.
+
+Let's elaborate.
+
+Imagine, you have two windows with the same site in each. So `localStorage` is shared between them.
+
+```online
+You might want to open this page in two browser windows to test the code below.
+```
+
+Now if both windows are listening for `window.onstorage`, then each one will react on updates that happened in the other one.
+
+```js run
+// triggers on updates made to the same storage from other documents
+window.onstorage = event => {
+  if (event.key != 'now') return;
+  alert(event.key + ':' + event.newValue + " at " + event.url);
+};
+
+localStorage.setItem('now', Date.now());
+```
+
+Please note that the event also contains: `event.url` -- the url of the document where the data was updated.
+
+Also, `event.storageArea` contains the storage object -- the event is the same for both `sessionStorage` and `localStorage`, so `storageArea` references the one that was modified. We may event want to set something back in it, to "respond" to a change.
+
+**That allows different windows from the same origin to exchange messages.**
+
+Modern browsers also support [Broadcast channel API](https://developer.mozilla.org/en-US/docs/Web/API/Broadcast_Channel_API), the special API for same-origin inter-window communication, it's more full featured, but less supported. There are libraries that polyfill that API, based on `localStorage`, that make it available everywhere.
+
+## Summary
+
+Web storage objects `localStorage` and `sessionStorage` allow to store key/value in the browser.
+- Both `key` and `value` must be strings.
+- The limit is 2mb+, depends on the browser.
+- They do not expire.
+- The data is bound to the origin (domain/port/protocol).
+
+| `localStorage` | `sessionStorage` |
+|----------------|------------------|
+| Shared between all tabs and windows with the same origin | Visible within a browser tab, including iframes from the same origin |
+| Survives browser restart | Dies on tab close |
+
+API:
+
+- `setItem(key, value)` -- store key/value pair.
+- `getItem(key)` -- get the value by key.
+- `removeItem(key)` -- remove the key with its value.
+- `clear()` -- delete everything.
+- `key(index)` -- get the key on a given position.
+- `length` -- the number of stored items.
+- Use `Object.keys` to get all keys.
+- Can use the keys as object properties, in that case `storage` event doesn't trigger.
+
+Storage event:
+
+- Triggers on `setItem`, `removeItem`, `clear` calls.
+- Contains all the data about the operation, the document `url` and the storage object.
+- Triggers on all `window` objects that have access to the storage except the one that generated it (within a tab for `sessionStorage`, globally for `localStorage`).
diff --git a/6-data-storage/02-localstorage/sessionstorage.view/iframe.html b/6-data-storage/02-localstorage/sessionstorage.view/iframe.html
new file mode 100644
index 000000000..2555160b5
--- /dev/null
+++ b/6-data-storage/02-localstorage/sessionstorage.view/iframe.html
@@ -0,0 +1,9 @@
+<!doctype html>
+<script>
+  window.addEventListener('storage', event => {
+    alert("iframe.html: onstorage");
+  });
+</script>
+<button onclick="sessionStorage.setItem('now', new Date())">sessionStorage.setItem</button>
+</body>
+</html>
diff --git a/6-data-storage/02-localstorage/sessionstorage.view/index.html b/6-data-storage/02-localstorage/sessionstorage.view/index.html
new file mode 100644
index 000000000..110143e58
--- /dev/null
+++ b/6-data-storage/02-localstorage/sessionstorage.view/index.html
@@ -0,0 +1,10 @@
+<!doctype html>
+<script>
+  window.addEventListener('storage', event => {
+    alert("index.html: onstorage");
+  });
+</script>
+<button onclick="sessionStorage.setItem('now', new Date())">sessionStorage.setItem</button>
+<iframe src="iframe.html" style="height:100px"></iframe>
+</body>
+</html>
diff --git a/6-data-storage/03-indexeddb/article.md b/6-data-storage/03-indexeddb/article.md
new file mode 100644
index 000000000..d7fc5bbbd
--- /dev/null
+++ b/6-data-storage/03-indexeddb/article.md
@@ -0,0 +1,754 @@
+libs:
+  - 'https://cdn.jsdelivr.net/npm/idb@3.0.2/build/idb.min.js'
+
+---
+
+# IndexedDB
+
+IndexedDB is a built-in database, much more powerful than `localStorage`.
+
+- Key/value storage: value can be (almost) anything, multiple key types.
+- Supports transactions for reliability.
+- Supports key range queries, indexes.
+- Can store much more data than `localStorage`.
+
+That power is usually excessive for traditional client-server apps. IndexedDB is intended for offline apps, to be combined with ServiceWorkers and other technologies.
+
+The native interface to IndexedDB, described in the specification <https://www.w3.org/TR/IndexedDB>, is event-based.
+
+We can also use `async/await` with the help of a promise-based wrapper, like <https://github.com/jakearchibald/idb>. That's pretty convenient, but the wrapper is not perfect, it can't replace events for all cases, so we'll start with events, and then use the wrapper.
+
+## Open database
+
+To start working with IndexedDB, we need to open a database.
+
+The syntax:
+
+```js
+let openRequest = indexedDB.open(name, version);
+```
+
+- `name` -- a string, the database name.
+- `version` -- a positive integer version, by default `1` (explained below).
+
+We can have many databases with different names, all within the current origin (domain/protocol/port). So different websites can't access databases of each other.
+
+After the call, we need to listen to events on `openRequest` object:
+- `success`: database is ready, use the database object `openRequest.result` for further work.
+- `error`: open failed.
+- `upgradeneeded`: database version is outdated (see below).
+
+**IndexedDB has a built-in mechanism of "schema versioning", absent in server-side databases.**
+
+Unlike server-side databases, IndexedDB is client-side, we don't have the data at hands. But when we publish a new version of our app, we may need to update the database.
+
+If the local database version is less than specified in `open`, then a special event `upgradeneeded` is triggered, and we can compare versions and upgrade data structures as needed.
+
+The event also triggers when the database did not exist yet, so we can perform initialization.
+
+For instance, when we first publish our app, we open it with version `1` and perform the initialization in `upgradeneeded` handler:
+
+```js
+let openRequest = indexedDB.open("store", *!*1*/!*);
+
+openRequest.onupgradeneeded = function() {
+  // triggers if the client had no database
+  // ...perform initialization...
+};
+
+openRequest.onerror = function() {
+  console.error("Error", openResult.error);
+};
+
+openRequest.onsuccess = function() {
+  let db = openRequest.result;
+  // continue to work with database using db object
+};
+```
+
+When we publish the 2nd version:
+
+```js
+let openRequest = indexedDB.open("store", *!*2*/!*);
+
+//  check the existing database version, do the updates if needed:
+openRequest.onupgradeneeded = function() {
+  let db = openRequest.result;
+  switch(db.version) { // existing (old) db version
+    case 0:
+      // version 0 means that the client had no database
+      // perform initialization
+    case 1:
+      // client had version 1
+      // update
+  }
+};
+```
+
+After `openRequest.onsuccess` we have the database object in `openRequest.result`, that we'll use for further operations.
+
+To delete a database:
+
+```js
+let deleteRequest = indexedDB.deleteDatabase(name)
+// deleteRequest.onsuccess/onerror tracks the result
+```
+
+
+## Object store
+
+An object store is a core concept of IndexedDB. Counterparts in other databases are called "tables" or "collections". It's where the data is stored. A database may have multiple stores: one for users, another one for goods, etc.
+
+Despite being named an "object store", primitives can be stored too.
+
+**We can store almost any value, including complex objects.**
+
+IndexedDB uses the [standard serialization algorithm](https://www.w3.org/TR/html53/infrastructure.html#section-structuredserializeforstorage) to clone-and-store an object. It's like `JSON.stringify`, but more powerful, capable of storing much more datatypes.
+
+An example of object that can't be stored: an object with circular references. Such objects are not serializable. `JSON.stringify` also fails for such objects.
+
+**There must be an unique `key` for every value in the store.**     
+
+A key must have a type one of: number, date, string, binary, or array. It's a unique object identifier: we can search/remove/update values by the key.
+
+![](indexeddb-structure.png)
+
+We can provide a key when we add an value to the store, similar to `localStorage`. That's good for storing primitive values. But when we store objects, IndexedDB allows to setup an object property as the key, that's much more convenient. Or we can auto-generate keys.
+
+The syntax to create an object store:
+```js
+db.createObjectStore(name[, keyOptions]);
+```
+
+Please note, the operation is synchronous, no `await` needed.
+
+- `name` is the store name, e.g. `"books"` for books,
+- `keyOptions` is an optional object with one of two properties:
+  - `keyPath` -- a path to an object property that IndexedDB will use as the key, e.g. `id`.
+  - `autoIncrement` -- if `true`, then the key for a newly stored object is generated automatically, as an ever-incrementing number.
+
+If we don't supply any options, then we'll need to provide a key explicitly later, when storing an object.
+
+For instance, this object store uses `id` property as the key:
+```js
+db.createObjectStore('books', {keyPath: 'id'});
+```
+
+**An object store can only be created/modified while updating the DB version, in `upgradeneeded` handler.**
+
+That's a technical limitation. Outside of the handler we'll be able to add/remove/update the data, but object stores are changed only during version update.
+
+To do an upgrade, there are two main ways:
+1. We can compare versions and run per-version operations.
+2. Or we can get a list of existing object stores as `db.objectStoreNames`. That object is a [DOMStringList](https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#domstringlist), and it provides `contains(name)` method to check for the existance. And then we can do updates depending on what exists.
+
+Here's the demo of the second approach:
+
+```js
+let openRequest = indexedDB.open("db", 1);
+
+// create an object store for books if not exists
+openRequest.onupgradeneeded = function() {
+  let db = openRequest.result;
+  if (!db.objectStoreNames.contains('books')) {
+    db.createObjectStore('books', {keyPath: 'id'});
+  }
+};
+```
+
+
+To delete an object store:
+
+```js
+db.deleteObjectStore('books')
+```
+
+## Transactions
+
+The term "transaction" is generic, used in many kinds of databases.
+
+A transaction is a group operations, that should either all succeed or all fail.
+
+For instance, when a person buys something, we need:
+1. Subtract the money from their account.
+2. Add the item to their inventory.
+
+It would be pretty bad if we complete the 1st operation, and then something goes wrong, e.g. lights out, and we fail to do the 2nd. Both should either succeed (purchase complete, good!) or both fail (at least the person kept their money, so they can retry).
+
+Transactions can guarantee that.
+
+**All data operations must be made within a transaction in IndexedDB.**
+
+To start a transaction:
+
+```js run
+db.transaction(store[, type]);
+```
+
+- `store` is a store name that the transaction is going to access, e.g. `"books"`. Can be an array of store names if we're going to access multiple stores.
+- `type` – a transaction type, one of:
+  - `readonly` -- can only read, the default.
+  - `readwrite` -- can only read and write, but not modify object stores.
+
+There'is also `versionchange` transaction type: such transactions can do everything, but we can't create them manually. IndexedDB automatically creates a `versionchange` transaction when opening the database, for `updateneeded` handler. That's why it's a single place where we can update the database structure, create/remove object stores.
+
+```smart header="What are transaction types for?"
+Performance is the reason why transactions need to be labeled either `readonly` and `readwrite`.
+
+Many `readonly` transactions can access concurrently the same store, but `readwrite` transactions can't. A `readwrite` transaction "locks" the store for writing. The next transaction must wait before the previous one finishes before accessing the same store.
+```
+
+After the transaction is created, we can add an item to the store, like this:
+
+```js
+let transaction = db.transaction("books", "readwrite"); // (1)
+
+// get an object store to operate on it
+*!*
+let books = transaction.objectStore("books"); // (2)
+*/!*
+
+let book = {
+  id: 'js',
+  price: 10,
+  created: new Date()
+};
+
+*!*
+let request = books.add(book); // (3)
+*/!*
+
+request.onsuccess = function() { // (4)
+  console.log("Book added to the store", request.result);
+};
+
+request.onerror = function() {
+  console.log("Error", request.error);
+};
+```
+
+There are basically four steps:
+
+1. Create a transaction, mention all stores it's going to access, at `(1)`.
+2. Get the store object using `transaction.objectStore(name)`, at `(2)`.
+3. Perform the request to the object store `books.add(book)`, at `(3)`.
+4. ...Handle request success/error `(4)`, make other requests if needed, etc.
+
+Object stores support two methods to store a value:
+
+- **put(value, [key])**
+    Add the `value` to the store. The `key` is supplied only if the object store did not have `keyPath` or `autoIncrement` option. If there's already a value with same key, it will be replaced.
+
+- **add(value, [key])**
+    Same as `put`, but if there's already a value with the same key, then the request fails, and an error with the name `"ConstraintError"` is generated.
+
+Just like when opening a database, we send a request: `books.add(book)`, and then wait for `success/error` events.
+
+- The `request.result` for `add` is the key of the new object.
+- The error is in `request.error` (if any).
+
+## Transactions autocommit
+
+In the example above we started the transaction and made `add` request. We could make more requests. How do we finish ("commit") the transaction?
+
+The short answer is: we don't.
+
+In the next version 3.0 of the specification, there will probably be a manual way to finish the transaction, but right now in 2.0 there isn't.
+
+**When all transaction requests are finished, and the [microtasks queue](info:microtask-queue) is empty, it is committed automatically.**
+
+```smart header="What's an \"empty microtask queue\"?"
+The microtask queue is explained in [another chapter](info:async-await#microtask-queue). In short, an empty microtask queue means that for all settled promises their `.then/catch/finally` handlers are executed.
+
+In other words, handling of finished promises and resuming "awaits" is done before closing the transaction.
+
+That's a minor technical detail. If we're using `async/await` instead of low-level promise calls, then we can assume that a transaction commits when all its requests are done, and the current code finishes.
+```
+
+So, in the example above no special code is needed to finish the transaction.
+
+Transactions auto-commit principle has an important side effect. We can't insert an async operation like `fetch`, `setTimeout` in the middle of transaction. IndexedDB will not keep the transaction waiting till these are done.
+
+In the code below `request2` in line `(*)` fails, because the transaction is already committed, can't make any request in it:
+
+```js
+let request1 = books.add(book);
+
+request1.onsuccess = function() {
+  fetch('/').then(response => {
+*!*
+    let request2 = books.add(anotherBook); // (*)
+*/!*
+    request2.onerror = function() {
+      console.log(request2.error.name); // TransactionInactiveError
+    };
+  });
+};
+```
+
+That's because `fetch` is an asynchronous operation, a macrotask. Transactions are closed before the browser starts doing macrotasks.
+
+Authors of IndexedDB spec believe that transactions should be short-lived. Mostly for performance reasons.
+
+Notably, `readwrite` transactions "lock" the stores for writing. So if one part of application initiated `readwrite` on `books` object store, then another part that wants to do the same has to wait: the new transaction "hangs" till the first one is done. That can lead to strange delays if transactions take a long time.
+
+So, what to do?
+
+In the example above we could make a new `db.transaction` right before the new request `(*)`.
+
+But it will be even better, if we'd like to keep the operations together, in one transaction, to split apart IndexedDB transactions and "other" async stuff.
+
+First, make `fetch`, prepare the data if needed, afterwards create a transaction and perform all the database requests, it'll work then.
+
+To detect the moment of successful completion, we can listen to `transaction.oncomplete` event:
+
+```js
+let transaction = db.transaction("books", "readwrite");
+
+// ...perform operations...
+
+transaction.oncomplete = function() {
+  console.log("Transaction is complete");
+};
+```
+
+Only `complete` guarantees that the transaction is saved as a whole. Individual requests may succeed, but the final write operation may go wrong (e.g. I/O error or something).
+
+To manually abort the transaction, call:
+
+```js
+transaction.abort();
+```
+
+That cancels all modification made by the requests in it and triggers `transaction.onabort` event.
+
+
+## Error handling
+
+Write requests may fail.
+
+That's to be expected, not only because of possible errors at our side, but also for reasons not related to the transaction itself. For instance, the storage quota may be exceeded. So we must be ready to handle such case.
+
+**A failed request automatically aborts the transaction, canceling all its changes.**
+
+Sometimes a request may fail with a non-critical error. We'd like to handle it in `request.onerror` and continue the transaction. Then, to prevent the transaction abort, we should call `event.preventDefault()`.
+
+In the example below a new book is added with the same key (`id`). The `store.add` method generates a `"ConstraintError"` in that case. We handle it without canceling the transaction:
+
+```js
+let transaction = db.transaction("books", "readwrite");
+
+let book = { id: 'js', price: 10 };
+
+let request = transaction.objectStore("books").add(book);
+
+request.onerror = function(event) {
+  // ConstraintError occurs when an object with the same id already exists
+  if (request.error.name == "ConstraintError") {
+    console.log("Book with such id already exists"); // handle the error
+    event.preventDefault(); // don't abort the transaction
+  } else {
+    // unexpected error, can't handle it
+    // the transaction will abort
+  }
+};
+
+transaction.onabort = function() {
+  console.log("Error", transaction.error);
+};
+```
+
+### Event delegation
+
+Do we need onerror/onsuccess for every request? Not every time. We can use event delegation instead.
+
+**IndexedDB events bubble: `request` -> `transaction` -> `database`.**
+
+All events are DOM events, with capturing and bubbling, but usually only bubbling stage is used.
+
+So we can catch all errors using `db.onerror` handler, for reporting or other purposes:
+
+```js
+db.onerror = function(event) {
+  let request = event.target; // the request that caused the error
+
+  console.log("Error", request.error);
+};
+```
+
+...But what if an error is fully handled? We don't want to report it in that case.
+
+We can stop the bubbling and hence `db.onerror` by using `event.stopPropagation()` in `request.onerror`.
+
+```js
+request.onerror = function(event) {
+  if (request.error.name == "ConstraintError") {
+    console.log("Book with such id already exists"); // handle the error
+    event.preventDefault(); // don't abort the transaction
+    event.stopPropagation(); // don't bubble error up, "chew" it
+  } else {
+    // do nothing
+    // transaction will be aborted
+    // we can take care of error in transaction.onabort
+  }
+};
+```
+
+## Searching by keys
+
+There are two main ways to search in an object store:
+1. By a key or a key range. That is: by `book.id` in our "books" storage.
+2. By another object field, e.g. `book.price`. We need an index for that.
+
+First let's deal with the keys and key ranges `(1)`.
+
+Methods that involve searching support either exact keys or so-called "range queries" -- [IDBKeyRange](https://www.w3.org/TR/IndexedDB/#keyrange) objects that specify a "key range".
+
+Ranges are created using following calls:
+
+- `IDBKeyRange.lowerBound(lower, [open])` means: `>lower` (or `≥lower` if `open` is true)
+- `IDBKeyRange.upperBound(upper, [open])` means: `<upper` (or `≤upper` if `open` is true)
+- `IDBKeyRange.bound(lower, upper, [lowerOpen], [upperOpen])` means: between `lower` and `upper`, with optional equality if the corresponding `open` is true.
+- `IDBKeyRange.only(key)` -- a range that consists of only one `key`, rarely used.
+
+All searching methods accept a `query` argument that can be either an exact key or a key range:
+
+- `store.get(query)` -- search for the first value by a key or a range.
+- `store.getAll([query], [count])` -- search for all values, limit by `count` if given.
+- `store.getKey(query)` -- search for the first key that satisfies the query, usually a range.
+- `store.getAllKeys([query], [count])` -- search for all keys that satisfy the query, usually a range, up to `count` if given.
+- `store.count([query])` -- get the total count of keys that satisfy the query, usually a range.
+
+For instance, we have a lot of books in our store. Remember, the `id` field is the key, so all these methods can search by `id`.
+
+Request examples:
+
+```js
+// get one book
+books.get('js')
+
+// get books with 'css' < id < 'html'
+books.getAll(IDBKeyRange.bound('css', 'html'))
+
+// get books with 'html' <= id
+books.getAll(IDBKeyRange.lowerBound('html', true))
+
+// get all books
+books.getAll()
+
+// get all keys: id >= 'js'
+books.getAllKeys(IDBKeyRange.lowerBound('js', true))
+```
+
+```smart header="Object store is always sorted"
+Object store sorts values by key internally.
+
+So requests that return many values always return them in sorted by key order.
+```
+
+
+## Searching by any field with an index
+
+To search by other object fields, we need to create an additional data structure named "index".
+
+An index is an "add-on" to the store that tracks a given object field. For each value of that field, it stores a list of keys for objects that have that value. There will be a more detailed picture below.
+
+The syntax:
+
+```js
+objectStore.createIndex(name, keyPath, [options]);
+```
+
+- **`name`** -- index name,
+- **`keyPath`** -- path to the object field that the index should track (we're going to search by that field),
+- **`option`** -- an optional object with properties:
+  - **`unique`** -- if true, then there may be only one object in the store with the given value at the `keyPath`. The index will enforce that by generating an error if we try to add a duplicate.
+  - **`multiEntry`** -- only used if there value on `keyPath` is an array. In that case, by default, the index will treat the whole array as the key. But if `multiEntry` is true, then the index will keep a list of store objects for each value in that array. So array members become index keys.
+
+In our example, we store books keyed by `id`.
+
+Let's say we want to search by `price`.
+
+First, we need to create an index. It must be done in `upgradeneeded`, just like an object store:
+
+```js
+openRequest.onupgradeneeded = function() {
+  // we must create the index here, in versionchange transaction
+  let books = db.createObjectStore('books', {keyPath: 'id'});
+*!*
+  let index = inventory.createIndex('price_idx', 'price');
+*/!*
+};
+```
+
+- The index will track `price` field.
+- The price is not unique, there may be multiple books with the same price, so we don't set `unique` option.
+- The price is not an array, so `multiEntry` flag is not applicable.
+
+Imagine that our `inventory` has 4 books. Here's the picture that shows exactly what the `index` is:
+
+![](indexeddb-index.png)
+
+As said, the index for each value of `price` (second argument) keeps the list of keys that have that price.
+
+The index keeps itself up to date automatically, we don't have to care about it.
+
+Now, when we want to search for a given price, we simply apply the same search methods to the index:
+
+```js
+let transaction = db.transaction("books"); // readonly
+let books = transaction.objectStore("books");
+let priceIndex = books.index("price_idx");
+
+*!*
+let request = priceIndex.getAll(10);
+*/!*
+
+request.onsuccess = function() {
+  if (request.result !== undefined) {
+    console.log("Books", request.result); // array of books with price=10
+  } else {
+    console.log("No such books");
+  }
+};
+```
+
+We can also use `IDBKeyRange` to create ranges and looks for cheap/expensive books:
+
+```js
+// find books where price < 5
+let request = priceIndex.getAll(IDBKeyRange.upperBound(5));
+```
+
+Indexes are internally sorted by the tracked object field, `price` in our case. So when we do the search, the results are also sorted by `price`.
+
+## Deleting from store
+
+The `delete` method looks up values to delete by a query, just like `getAll`.
+
+- **`delete(query)`** -- delete matching values by query.
+
+For instance:
+```js
+// delete the book with id='js'
+books.delete('js');
+```
+
+If we'd like to delete books based on a price or another object field, then we should first find the key in the index, and then call `delete`:
+
+```js
+// find the key where price = 5
+let request = priceIndex.getKey(5);
+
+request.onsuccess = function() {
+  let id = request.result;
+  let deleteRequest = books.delete(id);
+};
+```
+
+To delete everything:
+```js
+books.clear(); // clear the storage.
+```
+
+## Cursors
+
+Methods like `getAll/getAllKeys` return an array of keys/values.
+
+But an object storage can be huge, bigger than the available memory.
+
+Then `getAll` will fail to get all records as an array.
+
+What to do?
+
+Cursors provide the means to work around that.
+
+**A *cursor* is a special object that traverses the object storage, given a query, and returns one key/value at a time, thus saving memory.**
+
+As an object store is sorted internally by key, a cursor walks the store in key order (ascending by default).
+
+The syntax:
+```js
+// like getAll, but with a cursor:
+let request = store.openCursor(query, [direction]);
+
+// to get keys, not values (like getAllKeys): store.openKeyCursor
+```
+
+- **`query`** is a key or a key range, same as for `getAll`.
+- **`direction`** is an optional argument, which order to use:
+  - `"next"` -- the default, the cursor walks up from the record with the lowest key.
+  - `"prev"` -- the reverse order: down from the record with the biggest key.
+  - `"nextunique"`, `"prevunique"` -- same as above, but skip records with the same key (only for cursors over indexes, e.g. for multiple books with price=5 only the first one will be returned).
+
+**The main difference of the cursor is that `request.onsuccess` triggers multiple times: once for each result.**
+
+Here's an example of how to use a cursor:
+
+```js
+let transaction = db.transaction("books");
+let books = transaction.objectStore("books");
+
+let request = books.openCursor();
+
+// called for each book found by the cursor
+request.onsuccess = function() {
+  let cursor = request.result;
+  if (cursor) {
+    let key = cursor.key; // book key (id field)
+    let value = cursor.value; // book object
+    console.log(key, value);
+    cursor.continue();
+  } else {
+    console.log("No more books");
+  }
+};
+```
+
+The main cursor methods are:
+
+- `advance(count)` -- advance the cursor `count` times, skipping values.
+- `continue([key])` -- advance the cursor to the next value in range matching or after key.
+
+Whether there are more values matching the cursor or not -- `onsuccess` gets called, and then in `result` we can get the cursor pointing to the next record, or `undefined`.
+
+In the example above the cursor was made for the object store.
+
+But we also can make a cursor over an index. As we remember, indexes allow to search by an object field. Cursors over indexes to precisely the same as over object stores -- they save memory by returning one value at a timee.
+
+For cursors over indexes, `cursor.key` is the index key (e.g. price), and we should use `cursor.primaryKey` property the object key:
+
+```js
+let request = priceIdx.openCursor(IDBKeyRange.upperBound(5));
+
+// called for each record
+request.onsuccess = function() {
+  let cursor = request.result;
+  if (cursor) {
+    let key = cursor.primaryKey; // next object store key (id field)
+    let value = cursor.value; // next object store object (book object)
+    let key = cursor.key; // next index key (price)
+    console.log(key, value);
+    cursor.continue();
+  } else {
+    console.log("No more books");
+  }
+};
+```
+
+## Promise wrapper
+
+Adding `onsuccess/onerror` to every request is quite a cumbersome task. Sometimes we can make our life easier by using event delegation, e.g. set handlers on the whole transactions, but `async/await` is much more convenient.
+
+Let's use a thin promise wrapper <https://github.com/jakearchibald/idb> further in this chapter. It creates a global `idb` object with [promisified](info:promisify) IndexedDB methods.
+
+Then, instead of `onsuccess/onerror` we can write like this:
+
+```js
+let db = await idb.openDb('store', 1, db => {
+  if (db.oldVersion == 0) {
+    // perform the initialization
+    db.createObjectStore('books', {keyPath: 'id'});
+  }
+});
+
+let transaction = db.transaction('books', 'readwrite');
+let books = transaction.objectStore('books');
+
+try {
+  await books.add(...);
+  await books.add(...);
+
+  await transaction.complete;
+
+  console.log('jsbook saved');
+} catch(err) {
+  console.log('error', err.message);
+}
+
+```
+
+So we have all the sweet "plain async code" and "try..catch" stuff.
+
+### Error handling
+
+If we don't catch the error, then it falls through, just as usual.
+
+An uncaught error becomes an "unhandled promise rejection" event on `window` object.
+
+We can handle such errors like this:
+
+```js
+window.addEventListener('unhandledrejection', event => {
+  let request = event.target; // IndexedDB native request object
+  let error = event.reason; //  Unhandled error object, same as request.error
+  ...report about the error...
+});
+```
+
+### "Inactive transaction" pitfall
+
+A we know already, a transaction auto-commits as soon as the browser is done with the current code and microtasks. So if we put an *macrotask* like `fetch` in the middle of a transaction, then the transaction won't wait for it to finish. It just auto-commits. So the next request in it fails.
+
+For a promise wrapper and `async/await` the situation is the same.
+
+Here's an example of `fetch` in the middle of the transaction:
+
+```js
+let transaction = db.transaction("inventory", "readwrite");
+let inventory = transaction.objectStore("inventory");
+
+await inventory.add({ id: 'js', price: 10, created: new Date() });
+
+await fetch(...); // (*)
+
+await inventory.add({ id: 'js', price: 10, created: new Date() }); // Error
+```
+
+The next `inventory.add` after `fetch` `(*)` fails with an "inactive transaction" error, because the transaction is already committed and closed at that time.
+
+The workaround is same as when working with native IndexedDB: either make a new transaction or just split things apart.
+1. Prepare the data and fetch all that's needed first.
+2. Then save in the database.
+
+### Getting native objects
+
+Internally, the wrapper performs a native IndexedDB request, adding `onerror/onsuccess` to it, and returns a promise that rejects/resolves with the result.
+
+That works most fine of the time. The examples are at the lib page <https://github.com/jakearchibald/idb>.
+
+In few rare cases, when we need the original `request` object, we can access it as `promise.request` property of the promise:
+
+```js
+let promise = books.add(book); // get a promise (don't await for its result)
+
+let request = promise.request; // native request object
+let transaction = request.transaction; // native transaction object
+
+// ...do some native IndexedDB voodoo...
+
+let result = await promise; // if still needed
+```
+
+## Summary
+
+IndexedDB can be thought of as a "localStorage on steroids". It's a simple key-value database, powerful enough for offline apps, yet simple to use.
+
+The best manual is the specification, [the current one](https://w3c.github.io/IndexedDB) is 2.0, but few methods from [3.0](https://w3c.github.io/IndexedDB/) (it's not much different) are partially supported.
+
+The usage can be described with a few phrases:
+
+1. Get a promise wrapper like [idb](https://github.com/jakearchibald/idb).
+2. Open a database: `idb.openDb(name, version, onupgradeneeded)`
+    - Create object storages in indexes in `onupgradeneeded` handlers.
+    - Update version if needed - either by comparing numbers or just checking what exists.
+3. For requests:
+    - Create transaction `db.transaction('books')` (readwrite if needed).
+    - Get the object store `transaction.objectStore('books')`.
+4. Then, to search by a key, call methods on the object store directly.
+    - To search by an object field, create an index.
+5. If the data does not fit in memory, use a cursor.
+
+Here's a small demo app:
+
+[codetabs src="books" current="index.html"]
diff --git a/6-data-storage/03-indexeddb/books.view/index.html b/6-data-storage/03-indexeddb/books.view/index.html
new file mode 100644
index 000000000..11c12da7b
--- /dev/null
+++ b/6-data-storage/03-indexeddb/books.view/index.html
@@ -0,0 +1,70 @@
+<!doctype html>
+<script src="https://cdn.jsdelivr.net/npm/idb@3.0.2/build/idb.min.js"></script>
+
+<button onclick="addBook()">Add a book</button>
+<button onclick="clearBooks()">Clear books</button>
+
+<p>Books list:</p>
+
+<ul id="listElem"></ul>
+
+<script>
+let db;
+
+init();
+
+async function init() {
+  db = await idb.openDb('booksDb', 1, db => {
+    db.createObjectStore('books', {keyPath: 'name'});
+  });
+
+  list();
+}
+
+async function list() {
+  let tx = db.transaction('books');
+  let bookStore = tx.objectStore('books');
+
+  let books = await bookStore.getAll();
+
+  if (books.length) {
+    listElem.innerHTML = books.map(book => `<li>
+        name: ${book.name}, price: ${book.price}
+      </li>`).join('');
+  } else {
+    listElem.innerHTML = '<li>No books yet. Please add books.</li>'
+  }
+
+
+}
+
+async function clearBooks() {
+  let tx = db.transaction('books', 'readwrite');
+  await tx.objectStore('books').clear();
+  await list();
+}
+
+async function addBook() {
+  let name = prompt("Book name?");
+  let price = +prompt("Book price?");
+
+  let tx = db.transaction('books', 'readwrite');
+
+  try {
+    await tx.objectStore('books').add({name, price});
+    await list();
+  } catch(err) {
+    if (err.name == 'ConstraintError') {
+      alert("Such book exists already");
+      await addBook();
+    } else {
+      throw err;
+    }
+  }
+}
+
+window.addEventListener('unhandledrejection', event => {
+  alert("Error: " + event.reason.message);
+});
+
+</script>
diff --git a/6-data-storage/03-indexeddb/indexeddb-cursor.png b/6-data-storage/03-indexeddb/indexeddb-cursor.png
new file mode 100644
index 000000000..7c53219c9
Binary files /dev/null and b/6-data-storage/03-indexeddb/indexeddb-cursor.png differ
diff --git a/6-data-storage/03-indexeddb/indexeddb-cursor@2x.png b/6-data-storage/03-indexeddb/indexeddb-cursor@2x.png
new file mode 100644
index 000000000..f4392edfe
Binary files /dev/null and b/6-data-storage/03-indexeddb/indexeddb-cursor@2x.png differ
diff --git a/6-data-storage/03-indexeddb/indexeddb-index.png b/6-data-storage/03-indexeddb/indexeddb-index.png
new file mode 100644
index 000000000..4fdc18976
Binary files /dev/null and b/6-data-storage/03-indexeddb/indexeddb-index.png differ
diff --git a/6-data-storage/03-indexeddb/indexeddb-index@2x.png b/6-data-storage/03-indexeddb/indexeddb-index@2x.png
new file mode 100644
index 000000000..406890304
Binary files /dev/null and b/6-data-storage/03-indexeddb/indexeddb-index@2x.png differ
diff --git a/6-data-storage/03-indexeddb/indexeddb-structure.png b/6-data-storage/03-indexeddb/indexeddb-structure.png
new file mode 100644
index 000000000..642e4d742
Binary files /dev/null and b/6-data-storage/03-indexeddb/indexeddb-structure.png differ
diff --git a/6-data-storage/03-indexeddb/indexeddb-structure@2x.png b/6-data-storage/03-indexeddb/indexeddb-structure@2x.png
new file mode 100644
index 000000000..2e4f389fd
Binary files /dev/null and b/6-data-storage/03-indexeddb/indexeddb-structure@2x.png differ
diff --git a/6-data-storage/index.md b/6-data-storage/index.md
new file mode 100644
index 000000000..a08c05b58
--- /dev/null
+++ b/6-data-storage/index.md
@@ -0,0 +1,2 @@
+
+# Storing data in the browser
diff --git a/3-animation/1-bezier-curve/article.md b/7-animation/1-bezier-curve/article.md
similarity index 100%
rename from 3-animation/1-bezier-curve/article.md
rename to 7-animation/1-bezier-curve/article.md
diff --git a/7-animation/1-bezier-curve/bezier-car.png b/7-animation/1-bezier-curve/bezier-car.png
new file mode 100644
index 000000000..32d959655
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier-car.png differ
diff --git a/7-animation/1-bezier-curve/bezier-car@2x.png b/7-animation/1-bezier-curve/bezier-car@2x.png
new file mode 100644
index 000000000..9debd3ba9
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier-car@2x.png differ
diff --git a/7-animation/1-bezier-curve/bezier-letter.png b/7-animation/1-bezier-curve/bezier-letter.png
new file mode 100644
index 000000000..fa9d23225
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier-letter.png differ
diff --git a/7-animation/1-bezier-curve/bezier-letter@2x.png b/7-animation/1-bezier-curve/bezier-letter@2x.png
new file mode 100644
index 000000000..e7e59ffd2
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier-letter@2x.png differ
diff --git a/7-animation/1-bezier-curve/bezier-vase.png b/7-animation/1-bezier-curve/bezier-vase.png
new file mode 100644
index 000000000..6c92f2466
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier-vase.png differ
diff --git a/7-animation/1-bezier-curve/bezier-vase@2x.png b/7-animation/1-bezier-curve/bezier-vase@2x.png
new file mode 100644
index 000000000..ccb977d7c
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier-vase@2x.png differ
diff --git a/7-animation/1-bezier-curve/bezier2.png b/7-animation/1-bezier-curve/bezier2.png
new file mode 100644
index 000000000..50df50963
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier2.png differ
diff --git a/7-animation/1-bezier-curve/bezier2@2x.png b/7-animation/1-bezier-curve/bezier2@2x.png
new file mode 100644
index 000000000..66cb9a211
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier2@2x.png differ
diff --git a/7-animation/1-bezier-curve/bezier3-draw1.png b/7-animation/1-bezier-curve/bezier3-draw1.png
new file mode 100644
index 000000000..2f3b3f8e3
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier3-draw1.png differ
diff --git a/7-animation/1-bezier-curve/bezier3-draw1@2x.png b/7-animation/1-bezier-curve/bezier3-draw1@2x.png
new file mode 100644
index 000000000..bd9ff640c
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier3-draw1@2x.png differ
diff --git a/7-animation/1-bezier-curve/bezier3-draw2.png b/7-animation/1-bezier-curve/bezier3-draw2.png
new file mode 100644
index 000000000..aead6cea5
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier3-draw2.png differ
diff --git a/7-animation/1-bezier-curve/bezier3-draw2@2x.png b/7-animation/1-bezier-curve/bezier3-draw2@2x.png
new file mode 100644
index 000000000..8d03793ea
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier3-draw2@2x.png differ
diff --git a/7-animation/1-bezier-curve/bezier3-e.png b/7-animation/1-bezier-curve/bezier3-e.png
new file mode 100644
index 000000000..0e9b8d372
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier3-e.png differ
diff --git a/7-animation/1-bezier-curve/bezier3-e@2x.png b/7-animation/1-bezier-curve/bezier3-e@2x.png
new file mode 100644
index 000000000..21ad2bb12
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier3-e@2x.png differ
diff --git a/7-animation/1-bezier-curve/bezier3.png b/7-animation/1-bezier-curve/bezier3.png
new file mode 100644
index 000000000..0af6c479a
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier3.png differ
diff --git a/7-animation/1-bezier-curve/bezier3@2x.png b/7-animation/1-bezier-curve/bezier3@2x.png
new file mode 100644
index 000000000..1390cbaa7
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier3@2x.png differ
diff --git a/7-animation/1-bezier-curve/bezier4-e.png b/7-animation/1-bezier-curve/bezier4-e.png
new file mode 100644
index 000000000..4f0bcae59
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier4-e.png differ
diff --git a/7-animation/1-bezier-curve/bezier4-e@2x.png b/7-animation/1-bezier-curve/bezier4-e@2x.png
new file mode 100644
index 000000000..34e89e632
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier4-e@2x.png differ
diff --git a/7-animation/1-bezier-curve/bezier4.png b/7-animation/1-bezier-curve/bezier4.png
new file mode 100644
index 000000000..f4ebc4a3c
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier4.png differ
diff --git a/7-animation/1-bezier-curve/bezier4@2x.png b/7-animation/1-bezier-curve/bezier4@2x.png
new file mode 100644
index 000000000..ddf3c2ec4
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier4@2x.png differ
diff --git a/3-animation/1-bezier-curve/demo.svg b/7-animation/1-bezier-curve/demo.svg
similarity index 100%
rename from 3-animation/1-bezier-curve/demo.svg
rename to 7-animation/1-bezier-curve/demo.svg
diff --git a/3-animation/1-bezier-curve/pause.png b/7-animation/1-bezier-curve/pause.png
similarity index 100%
rename from 3-animation/1-bezier-curve/pause.png
rename to 7-animation/1-bezier-curve/pause.png
diff --git a/3-animation/1-bezier-curve/play.png b/7-animation/1-bezier-curve/play.png
similarity index 100%
rename from 3-animation/1-bezier-curve/play.png
rename to 7-animation/1-bezier-curve/play.png
diff --git a/3-animation/2-css-animations/1-animate-logo-css/solution.md b/7-animation/2-css-animations/1-animate-logo-css/solution.md
similarity index 100%
rename from 3-animation/2-css-animations/1-animate-logo-css/solution.md
rename to 7-animation/2-css-animations/1-animate-logo-css/solution.md
diff --git a/3-animation/2-css-animations/1-animate-logo-css/solution.view/index.html b/7-animation/2-css-animations/1-animate-logo-css/solution.view/index.html
similarity index 100%
rename from 3-animation/2-css-animations/1-animate-logo-css/solution.view/index.html
rename to 7-animation/2-css-animations/1-animate-logo-css/solution.view/index.html
diff --git a/3-animation/2-css-animations/1-animate-logo-css/source.view/index.html b/7-animation/2-css-animations/1-animate-logo-css/source.view/index.html
similarity index 100%
rename from 3-animation/2-css-animations/1-animate-logo-css/source.view/index.html
rename to 7-animation/2-css-animations/1-animate-logo-css/source.view/index.html
diff --git a/3-animation/2-css-animations/1-animate-logo-css/task.md b/7-animation/2-css-animations/1-animate-logo-css/task.md
similarity index 100%
rename from 3-animation/2-css-animations/1-animate-logo-css/task.md
rename to 7-animation/2-css-animations/1-animate-logo-css/task.md
diff --git a/7-animation/2-css-animations/2-animate-logo-bezier-css/bezier-up.png b/7-animation/2-css-animations/2-animate-logo-bezier-css/bezier-up.png
new file mode 100644
index 000000000..2318e2c03
Binary files /dev/null and b/7-animation/2-css-animations/2-animate-logo-bezier-css/bezier-up.png differ
diff --git a/7-animation/2-css-animations/2-animate-logo-bezier-css/bezier-up@2x.png b/7-animation/2-css-animations/2-animate-logo-bezier-css/bezier-up@2x.png
new file mode 100644
index 000000000..91155c099
Binary files /dev/null and b/7-animation/2-css-animations/2-animate-logo-bezier-css/bezier-up@2x.png differ
diff --git a/3-animation/2-css-animations/2-animate-logo-bezier-css/solution.md b/7-animation/2-css-animations/2-animate-logo-bezier-css/solution.md
similarity index 100%
rename from 3-animation/2-css-animations/2-animate-logo-bezier-css/solution.md
rename to 7-animation/2-css-animations/2-animate-logo-bezier-css/solution.md
diff --git a/3-animation/2-css-animations/2-animate-logo-bezier-css/solution.view/index.html b/7-animation/2-css-animations/2-animate-logo-bezier-css/solution.view/index.html
similarity index 100%
rename from 3-animation/2-css-animations/2-animate-logo-bezier-css/solution.view/index.html
rename to 7-animation/2-css-animations/2-animate-logo-bezier-css/solution.view/index.html
diff --git a/3-animation/2-css-animations/2-animate-logo-bezier-css/task.md b/7-animation/2-css-animations/2-animate-logo-bezier-css/task.md
similarity index 100%
rename from 3-animation/2-css-animations/2-animate-logo-bezier-css/task.md
rename to 7-animation/2-css-animations/2-animate-logo-bezier-css/task.md
diff --git a/6-async/04-promise-api/02-promise-errors-as-results-2/solution.md b/7-animation/2-css-animations/3-animate-circle/solution.md
similarity index 100%
rename from 6-async/04-promise-api/02-promise-errors-as-results-2/solution.md
rename to 7-animation/2-css-animations/3-animate-circle/solution.md
diff --git a/3-animation/2-css-animations/3-animate-circle/solution.view/index.html b/7-animation/2-css-animations/3-animate-circle/solution.view/index.html
similarity index 100%
rename from 3-animation/2-css-animations/3-animate-circle/solution.view/index.html
rename to 7-animation/2-css-animations/3-animate-circle/solution.view/index.html
diff --git a/3-animation/2-css-animations/3-animate-circle/source.view/index.html b/7-animation/2-css-animations/3-animate-circle/source.view/index.html
similarity index 100%
rename from 3-animation/2-css-animations/3-animate-circle/source.view/index.html
rename to 7-animation/2-css-animations/3-animate-circle/source.view/index.html
diff --git a/3-animation/2-css-animations/3-animate-circle/task.md b/7-animation/2-css-animations/3-animate-circle/task.md
similarity index 100%
rename from 3-animation/2-css-animations/3-animate-circle/task.md
rename to 7-animation/2-css-animations/3-animate-circle/task.md
diff --git a/3-animation/2-css-animations/article.md b/7-animation/2-css-animations/article.md
similarity index 100%
rename from 3-animation/2-css-animations/article.md
rename to 7-animation/2-css-animations/article.md
diff --git a/7-animation/2-css-animations/bezier-linear.png b/7-animation/2-css-animations/bezier-linear.png
new file mode 100644
index 000000000..0b1e53bb2
Binary files /dev/null and b/7-animation/2-css-animations/bezier-linear.png differ
diff --git a/7-animation/2-css-animations/bezier-linear@2x.png b/7-animation/2-css-animations/bezier-linear@2x.png
new file mode 100644
index 000000000..fa7963918
Binary files /dev/null and b/7-animation/2-css-animations/bezier-linear@2x.png differ
diff --git a/7-animation/2-css-animations/bezier-train-over.png b/7-animation/2-css-animations/bezier-train-over.png
new file mode 100644
index 000000000..ebe51a8a9
Binary files /dev/null and b/7-animation/2-css-animations/bezier-train-over.png differ
diff --git a/7-animation/2-css-animations/bezier-train-over@2x.png b/7-animation/2-css-animations/bezier-train-over@2x.png
new file mode 100644
index 000000000..2b444d66a
Binary files /dev/null and b/7-animation/2-css-animations/bezier-train-over@2x.png differ
diff --git a/3-animation/2-css-animations/boat.view/index.html b/7-animation/2-css-animations/boat.view/index.html
similarity index 100%
rename from 3-animation/2-css-animations/boat.view/index.html
rename to 7-animation/2-css-animations/boat.view/index.html
diff --git a/3-animation/2-css-animations/boat.view/style.css b/7-animation/2-css-animations/boat.view/style.css
similarity index 100%
rename from 3-animation/2-css-animations/boat.view/style.css
rename to 7-animation/2-css-animations/boat.view/style.css
diff --git a/3-animation/2-css-animations/digits-negative-delay.view/index.html b/7-animation/2-css-animations/digits-negative-delay.view/index.html
similarity index 100%
rename from 3-animation/2-css-animations/digits-negative-delay.view/index.html
rename to 7-animation/2-css-animations/digits-negative-delay.view/index.html
diff --git a/3-animation/2-css-animations/digits-negative-delay.view/script.js b/7-animation/2-css-animations/digits-negative-delay.view/script.js
similarity index 100%
rename from 3-animation/2-css-animations/digits-negative-delay.view/script.js
rename to 7-animation/2-css-animations/digits-negative-delay.view/script.js
diff --git a/3-animation/2-css-animations/digits-negative-delay.view/style.css b/7-animation/2-css-animations/digits-negative-delay.view/style.css
similarity index 100%
rename from 3-animation/2-css-animations/digits-negative-delay.view/style.css
rename to 7-animation/2-css-animations/digits-negative-delay.view/style.css
diff --git a/3-animation/2-css-animations/digits.view/index.html b/7-animation/2-css-animations/digits.view/index.html
similarity index 100%
rename from 3-animation/2-css-animations/digits.view/index.html
rename to 7-animation/2-css-animations/digits.view/index.html
diff --git a/3-animation/2-css-animations/digits.view/script.js b/7-animation/2-css-animations/digits.view/script.js
similarity index 100%
rename from 3-animation/2-css-animations/digits.view/script.js
rename to 7-animation/2-css-animations/digits.view/script.js
diff --git a/3-animation/2-css-animations/digits.view/style.css b/7-animation/2-css-animations/digits.view/style.css
similarity index 100%
rename from 3-animation/2-css-animations/digits.view/style.css
rename to 7-animation/2-css-animations/digits.view/style.css
diff --git a/7-animation/2-css-animations/ease-in-out.png b/7-animation/2-css-animations/ease-in-out.png
new file mode 100644
index 000000000..e0b179b6b
Binary files /dev/null and b/7-animation/2-css-animations/ease-in-out.png differ
diff --git a/7-animation/2-css-animations/ease-in-out@2x.png b/7-animation/2-css-animations/ease-in-out@2x.png
new file mode 100644
index 000000000..14726b33c
Binary files /dev/null and b/7-animation/2-css-animations/ease-in-out@2x.png differ
diff --git a/7-animation/2-css-animations/ease-in.png b/7-animation/2-css-animations/ease-in.png
new file mode 100644
index 000000000..df182377a
Binary files /dev/null and b/7-animation/2-css-animations/ease-in.png differ
diff --git a/7-animation/2-css-animations/ease-in@2x.png b/7-animation/2-css-animations/ease-in@2x.png
new file mode 100644
index 000000000..2d6e7ddbf
Binary files /dev/null and b/7-animation/2-css-animations/ease-in@2x.png differ
diff --git a/7-animation/2-css-animations/ease-out.png b/7-animation/2-css-animations/ease-out.png
new file mode 100644
index 000000000..c07ed1234
Binary files /dev/null and b/7-animation/2-css-animations/ease-out.png differ
diff --git a/7-animation/2-css-animations/ease-out@2x.png b/7-animation/2-css-animations/ease-out@2x.png
new file mode 100644
index 000000000..b49506a14
Binary files /dev/null and b/7-animation/2-css-animations/ease-out@2x.png differ
diff --git a/7-animation/2-css-animations/ease.png b/7-animation/2-css-animations/ease.png
new file mode 100644
index 000000000..37f5376b7
Binary files /dev/null and b/7-animation/2-css-animations/ease.png differ
diff --git a/7-animation/2-css-animations/ease@2x.png b/7-animation/2-css-animations/ease@2x.png
new file mode 100644
index 000000000..a77eb1036
Binary files /dev/null and b/7-animation/2-css-animations/ease@2x.png differ
diff --git a/3-animation/2-css-animations/step-end.view/index.html b/7-animation/2-css-animations/step-end.view/index.html
similarity index 100%
rename from 3-animation/2-css-animations/step-end.view/index.html
rename to 7-animation/2-css-animations/step-end.view/index.html
diff --git a/3-animation/2-css-animations/step-end.view/style.css b/7-animation/2-css-animations/step-end.view/style.css
similarity index 100%
rename from 3-animation/2-css-animations/step-end.view/style.css
rename to 7-animation/2-css-animations/step-end.view/style.css
diff --git a/3-animation/2-css-animations/step-list.view/index.html b/7-animation/2-css-animations/step-list.view/index.html
similarity index 100%
rename from 3-animation/2-css-animations/step-list.view/index.html
rename to 7-animation/2-css-animations/step-list.view/index.html
diff --git a/3-animation/2-css-animations/step-list.view/style.css b/7-animation/2-css-animations/step-list.view/style.css
similarity index 100%
rename from 3-animation/2-css-animations/step-list.view/style.css
rename to 7-animation/2-css-animations/step-list.view/style.css
diff --git a/3-animation/2-css-animations/step.view/index.html b/7-animation/2-css-animations/step.view/index.html
similarity index 100%
rename from 3-animation/2-css-animations/step.view/index.html
rename to 7-animation/2-css-animations/step.view/index.html
diff --git a/3-animation/2-css-animations/step.view/style.css b/7-animation/2-css-animations/step.view/style.css
similarity index 100%
rename from 3-animation/2-css-animations/step.view/style.css
rename to 7-animation/2-css-animations/step.view/style.css
diff --git a/7-animation/2-css-animations/train-curve.png b/7-animation/2-css-animations/train-curve.png
new file mode 100644
index 000000000..97b722944
Binary files /dev/null and b/7-animation/2-css-animations/train-curve.png differ
diff --git a/7-animation/2-css-animations/train-curve@2x.png b/7-animation/2-css-animations/train-curve@2x.png
new file mode 100644
index 000000000..40e8947fc
Binary files /dev/null and b/7-animation/2-css-animations/train-curve@2x.png differ
diff --git a/3-animation/2-css-animations/train-linear.view/index.html b/7-animation/2-css-animations/train-linear.view/index.html
similarity index 100%
rename from 3-animation/2-css-animations/train-linear.view/index.html
rename to 7-animation/2-css-animations/train-linear.view/index.html
diff --git a/3-animation/2-css-animations/train-linear.view/style.css b/7-animation/2-css-animations/train-linear.view/style.css
similarity index 100%
rename from 3-animation/2-css-animations/train-linear.view/style.css
rename to 7-animation/2-css-animations/train-linear.view/style.css
diff --git a/3-animation/2-css-animations/train-over.view/index.html b/7-animation/2-css-animations/train-over.view/index.html
similarity index 100%
rename from 3-animation/2-css-animations/train-over.view/index.html
rename to 7-animation/2-css-animations/train-over.view/index.html
diff --git a/3-animation/2-css-animations/train-over.view/style.css b/7-animation/2-css-animations/train-over.view/style.css
similarity index 100%
rename from 3-animation/2-css-animations/train-over.view/style.css
rename to 7-animation/2-css-animations/train-over.view/style.css
diff --git a/3-animation/2-css-animations/train.view/index.html b/7-animation/2-css-animations/train.view/index.html
similarity index 100%
rename from 3-animation/2-css-animations/train.view/index.html
rename to 7-animation/2-css-animations/train.view/index.html
diff --git a/3-animation/2-css-animations/train.view/style.css b/7-animation/2-css-animations/train.view/style.css
similarity index 100%
rename from 3-animation/2-css-animations/train.view/style.css
rename to 7-animation/2-css-animations/train.view/style.css
diff --git a/3-animation/3-js-animation/1-animate-ball/solution.md b/7-animation/3-js-animation/1-animate-ball/solution.md
similarity index 100%
rename from 3-animation/3-js-animation/1-animate-ball/solution.md
rename to 7-animation/3-js-animation/1-animate-ball/solution.md
diff --git a/3-animation/3-js-animation/1-animate-ball/solution.view/index.html b/7-animation/3-js-animation/1-animate-ball/solution.view/index.html
similarity index 100%
rename from 3-animation/3-js-animation/1-animate-ball/solution.view/index.html
rename to 7-animation/3-js-animation/1-animate-ball/solution.view/index.html
diff --git a/3-animation/3-js-animation/1-animate-ball/solution.view/style.css b/7-animation/3-js-animation/1-animate-ball/solution.view/style.css
similarity index 100%
rename from 3-animation/3-js-animation/1-animate-ball/solution.view/style.css
rename to 7-animation/3-js-animation/1-animate-ball/solution.view/style.css
diff --git a/3-animation/3-js-animation/1-animate-ball/source.view/index.html b/7-animation/3-js-animation/1-animate-ball/source.view/index.html
similarity index 100%
rename from 3-animation/3-js-animation/1-animate-ball/source.view/index.html
rename to 7-animation/3-js-animation/1-animate-ball/source.view/index.html
diff --git a/3-animation/3-js-animation/1-animate-ball/source.view/style.css b/7-animation/3-js-animation/1-animate-ball/source.view/style.css
similarity index 100%
rename from 3-animation/3-js-animation/1-animate-ball/source.view/style.css
rename to 7-animation/3-js-animation/1-animate-ball/source.view/style.css
diff --git a/3-animation/3-js-animation/1-animate-ball/task.md b/7-animation/3-js-animation/1-animate-ball/task.md
similarity index 100%
rename from 3-animation/3-js-animation/1-animate-ball/task.md
rename to 7-animation/3-js-animation/1-animate-ball/task.md
diff --git a/3-animation/3-js-animation/2-animate-ball-hops/solution.md b/7-animation/3-js-animation/2-animate-ball-hops/solution.md
similarity index 100%
rename from 3-animation/3-js-animation/2-animate-ball-hops/solution.md
rename to 7-animation/3-js-animation/2-animate-ball-hops/solution.md
diff --git a/3-animation/3-js-animation/2-animate-ball-hops/solution.view/index.html b/7-animation/3-js-animation/2-animate-ball-hops/solution.view/index.html
similarity index 100%
rename from 3-animation/3-js-animation/2-animate-ball-hops/solution.view/index.html
rename to 7-animation/3-js-animation/2-animate-ball-hops/solution.view/index.html
diff --git a/3-animation/3-js-animation/2-animate-ball-hops/solution.view/style.css b/7-animation/3-js-animation/2-animate-ball-hops/solution.view/style.css
similarity index 100%
rename from 3-animation/3-js-animation/2-animate-ball-hops/solution.view/style.css
rename to 7-animation/3-js-animation/2-animate-ball-hops/solution.view/style.css
diff --git a/3-animation/3-js-animation/2-animate-ball-hops/task.md b/7-animation/3-js-animation/2-animate-ball-hops/task.md
similarity index 100%
rename from 3-animation/3-js-animation/2-animate-ball-hops/task.md
rename to 7-animation/3-js-animation/2-animate-ball-hops/task.md
diff --git a/3-animation/3-js-animation/article.md b/7-animation/3-js-animation/article.md
similarity index 99%
rename from 3-animation/3-js-animation/article.md
rename to 7-animation/3-js-animation/article.md
index e98ee8f03..0975ebff5 100644
--- a/3-animation/3-js-animation/article.md
+++ b/7-animation/3-js-animation/article.md
@@ -8,7 +8,7 @@ For instance, moving along a complex path, with a timing function different from
 
 An animation can be implemented as a sequence of frames -- usually small changes to HTML/CSS properties.
 
-For instance, changing `style.left` from `0px` to `100px` moves the element. And if we increase it in `setInterval`, changing by `2px` with a tiny delay, like 50 times per second, then it looks smooth. That's the same principle as in the cinema: 24 or more frames per second is enough to make it look smooth.
+For instance, changing `style.left` from `0px` to `100px` moves the element. And if we increase it in `setInterval`, changing by `2px` with a tiny delay, like 50 times per second, then it looks smooth. That's the same principle as in the cinema: 24 frames per second is enough to make it look smooth.
 
 The pseudo-code can look like this:
 
diff --git a/7-animation/3-js-animation/back.png b/7-animation/3-js-animation/back.png
new file mode 100644
index 000000000..7a5d9a6fb
Binary files /dev/null and b/7-animation/3-js-animation/back.png differ
diff --git a/3-animation/3-js-animation/back.view/index.html b/7-animation/3-js-animation/back.view/index.html
similarity index 100%
rename from 3-animation/3-js-animation/back.view/index.html
rename to 7-animation/3-js-animation/back.view/index.html
diff --git a/3-animation/3-js-animation/back.view/style.css b/7-animation/3-js-animation/back.view/style.css
similarity index 100%
rename from 3-animation/3-js-animation/back.view/style.css
rename to 7-animation/3-js-animation/back.view/style.css
diff --git a/7-animation/3-js-animation/back@2x.png b/7-animation/3-js-animation/back@2x.png
new file mode 100644
index 000000000..dc90e1fcf
Binary files /dev/null and b/7-animation/3-js-animation/back@2x.png differ
diff --git a/7-animation/3-js-animation/bezier-linear.png b/7-animation/3-js-animation/bezier-linear.png
new file mode 100644
index 000000000..0b1e53bb2
Binary files /dev/null and b/7-animation/3-js-animation/bezier-linear.png differ
diff --git a/7-animation/3-js-animation/bezier-linear@2x.png b/7-animation/3-js-animation/bezier-linear@2x.png
new file mode 100644
index 000000000..fa7963918
Binary files /dev/null and b/7-animation/3-js-animation/bezier-linear@2x.png differ
diff --git a/3-animation/3-js-animation/bounce-easeinout.view/index.html b/7-animation/3-js-animation/bounce-easeinout.view/index.html
similarity index 100%
rename from 3-animation/3-js-animation/bounce-easeinout.view/index.html
rename to 7-animation/3-js-animation/bounce-easeinout.view/index.html
diff --git a/3-animation/3-js-animation/bounce-easeinout.view/style.css b/7-animation/3-js-animation/bounce-easeinout.view/style.css
similarity index 100%
rename from 3-animation/3-js-animation/bounce-easeinout.view/style.css
rename to 7-animation/3-js-animation/bounce-easeinout.view/style.css
diff --git a/3-animation/3-js-animation/bounce-easeout.view/index.html b/7-animation/3-js-animation/bounce-easeout.view/index.html
similarity index 100%
rename from 3-animation/3-js-animation/bounce-easeout.view/index.html
rename to 7-animation/3-js-animation/bounce-easeout.view/index.html
diff --git a/3-animation/3-js-animation/bounce-easeout.view/style.css b/7-animation/3-js-animation/bounce-easeout.view/style.css
similarity index 100%
rename from 3-animation/3-js-animation/bounce-easeout.view/style.css
rename to 7-animation/3-js-animation/bounce-easeout.view/style.css
diff --git a/7-animation/3-js-animation/bounce-inout.png b/7-animation/3-js-animation/bounce-inout.png
new file mode 100644
index 000000000..5c867fd7d
Binary files /dev/null and b/7-animation/3-js-animation/bounce-inout.png differ
diff --git a/7-animation/3-js-animation/bounce-inout@2x.png b/7-animation/3-js-animation/bounce-inout@2x.png
new file mode 100644
index 000000000..0527e4597
Binary files /dev/null and b/7-animation/3-js-animation/bounce-inout@2x.png differ
diff --git a/3-animation/3-js-animation/bounce.view/index.html b/7-animation/3-js-animation/bounce.view/index.html
similarity index 100%
rename from 3-animation/3-js-animation/bounce.view/index.html
rename to 7-animation/3-js-animation/bounce.view/index.html
diff --git a/3-animation/3-js-animation/bounce.view/style.css b/7-animation/3-js-animation/bounce.view/style.css
similarity index 100%
rename from 3-animation/3-js-animation/bounce.view/style.css
rename to 7-animation/3-js-animation/bounce.view/style.css
diff --git a/7-animation/3-js-animation/circ-ease.png b/7-animation/3-js-animation/circ-ease.png
new file mode 100644
index 000000000..2d3c6772e
Binary files /dev/null and b/7-animation/3-js-animation/circ-ease.png differ
diff --git a/7-animation/3-js-animation/circ-ease@2x.png b/7-animation/3-js-animation/circ-ease@2x.png
new file mode 100644
index 000000000..5984fdb60
Binary files /dev/null and b/7-animation/3-js-animation/circ-ease@2x.png differ
diff --git a/7-animation/3-js-animation/circ.png b/7-animation/3-js-animation/circ.png
new file mode 100644
index 000000000..51663c431
Binary files /dev/null and b/7-animation/3-js-animation/circ.png differ
diff --git a/3-animation/3-js-animation/circ.view/index.html b/7-animation/3-js-animation/circ.view/index.html
similarity index 100%
rename from 3-animation/3-js-animation/circ.view/index.html
rename to 7-animation/3-js-animation/circ.view/index.html
diff --git a/3-animation/3-js-animation/circ.view/style.css b/7-animation/3-js-animation/circ.view/style.css
similarity index 100%
rename from 3-animation/3-js-animation/circ.view/style.css
rename to 7-animation/3-js-animation/circ.view/style.css
diff --git a/7-animation/3-js-animation/circ@2x.png b/7-animation/3-js-animation/circ@2x.png
new file mode 100644
index 000000000..55fdbf377
Binary files /dev/null and b/7-animation/3-js-animation/circ@2x.png differ
diff --git a/7-animation/3-js-animation/elastic.png b/7-animation/3-js-animation/elastic.png
new file mode 100644
index 000000000..db9c112a3
Binary files /dev/null and b/7-animation/3-js-animation/elastic.png differ
diff --git a/3-animation/3-js-animation/elastic.view/index.html b/7-animation/3-js-animation/elastic.view/index.html
similarity index 100%
rename from 3-animation/3-js-animation/elastic.view/index.html
rename to 7-animation/3-js-animation/elastic.view/index.html
diff --git a/3-animation/3-js-animation/elastic.view/style.css b/7-animation/3-js-animation/elastic.view/style.css
similarity index 100%
rename from 3-animation/3-js-animation/elastic.view/style.css
rename to 7-animation/3-js-animation/elastic.view/style.css
diff --git a/7-animation/3-js-animation/elastic@2x.png b/7-animation/3-js-animation/elastic@2x.png
new file mode 100644
index 000000000..46c50779a
Binary files /dev/null and b/7-animation/3-js-animation/elastic@2x.png differ
diff --git a/7-animation/3-js-animation/linear.png b/7-animation/3-js-animation/linear.png
new file mode 100644
index 000000000..e19711c36
Binary files /dev/null and b/7-animation/3-js-animation/linear.png differ
diff --git a/7-animation/3-js-animation/linear@2x.png b/7-animation/3-js-animation/linear@2x.png
new file mode 100644
index 000000000..652dd175c
Binary files /dev/null and b/7-animation/3-js-animation/linear@2x.png differ
diff --git a/3-animation/3-js-animation/move-raf.view/index.html b/7-animation/3-js-animation/move-raf.view/index.html
similarity index 100%
rename from 3-animation/3-js-animation/move-raf.view/index.html
rename to 7-animation/3-js-animation/move-raf.view/index.html
diff --git a/3-animation/3-js-animation/move.view/index.html b/7-animation/3-js-animation/move.view/index.html
similarity index 100%
rename from 3-animation/3-js-animation/move.view/index.html
rename to 7-animation/3-js-animation/move.view/index.html
diff --git a/7-animation/3-js-animation/quad.png b/7-animation/3-js-animation/quad.png
new file mode 100644
index 000000000..c757cb0e3
Binary files /dev/null and b/7-animation/3-js-animation/quad.png differ
diff --git a/3-animation/3-js-animation/quad.view/index.html b/7-animation/3-js-animation/quad.view/index.html
similarity index 100%
rename from 3-animation/3-js-animation/quad.view/index.html
rename to 7-animation/3-js-animation/quad.view/index.html
diff --git a/3-animation/3-js-animation/quad.view/style.css b/7-animation/3-js-animation/quad.view/style.css
similarity index 100%
rename from 3-animation/3-js-animation/quad.view/style.css
rename to 7-animation/3-js-animation/quad.view/style.css
diff --git a/7-animation/3-js-animation/quad@2x.png b/7-animation/3-js-animation/quad@2x.png
new file mode 100644
index 000000000..b170e3209
Binary files /dev/null and b/7-animation/3-js-animation/quad@2x.png differ
diff --git a/7-animation/3-js-animation/quint.png b/7-animation/3-js-animation/quint.png
new file mode 100644
index 000000000..a71b91ba2
Binary files /dev/null and b/7-animation/3-js-animation/quint.png differ
diff --git a/3-animation/3-js-animation/quint.view/index.html b/7-animation/3-js-animation/quint.view/index.html
similarity index 100%
rename from 3-animation/3-js-animation/quint.view/index.html
rename to 7-animation/3-js-animation/quint.view/index.html
diff --git a/3-animation/3-js-animation/quint.view/style.css b/7-animation/3-js-animation/quint.view/style.css
similarity index 100%
rename from 3-animation/3-js-animation/quint.view/style.css
rename to 7-animation/3-js-animation/quint.view/style.css
diff --git a/7-animation/3-js-animation/quint@2x.png b/7-animation/3-js-animation/quint@2x.png
new file mode 100644
index 000000000..0e6a305b1
Binary files /dev/null and b/7-animation/3-js-animation/quint@2x.png differ
diff --git a/3-animation/3-js-animation/text.view/index.html b/7-animation/3-js-animation/text.view/index.html
similarity index 100%
rename from 3-animation/3-js-animation/text.view/index.html
rename to 7-animation/3-js-animation/text.view/index.html
diff --git a/3-animation/3-js-animation/text.view/style.css b/7-animation/3-js-animation/text.view/style.css
similarity index 100%
rename from 3-animation/3-js-animation/text.view/style.css
rename to 7-animation/3-js-animation/text.view/style.css
diff --git a/3-animation/3-js-animation/width.view/animate.js b/7-animation/3-js-animation/width.view/animate.js
similarity index 100%
rename from 3-animation/3-js-animation/width.view/animate.js
rename to 7-animation/3-js-animation/width.view/animate.js
diff --git a/3-animation/3-js-animation/width.view/index.html b/7-animation/3-js-animation/width.view/index.html
similarity index 100%
rename from 3-animation/3-js-animation/width.view/index.html
rename to 7-animation/3-js-animation/width.view/index.html
diff --git a/3-animation/index.md b/7-animation/index.md
similarity index 100%
rename from 3-animation/index.md
rename to 7-animation/index.md
diff --git a/7-network/1-xmlhttprequest/article.md b/7-network/1-xmlhttprequest/article.md
deleted file mode 100644
index 52b113568..000000000
--- a/7-network/1-xmlhttprequest/article.md
+++ /dev/null
@@ -1,400 +0,0 @@
-# XMLHttpRequest and AJAX
-
-`XMLHttpRequest` is a built-in browser object that allows to make HTTP requests in JavaScript.
-
-Despite of having the word "XML" in its name, it can operate on any data, not only in XML format.
-
-## Asynchronous XMLHttpRequest
-
-XMLHttpRequest has two modes of operation: synchronous and asynchronous.
-
-First let's see the asynchronous variant as it's used in the majority of cases.
-
-The code below loads the URL at `/article/xmlhttprequest/hello.txt` from the server and shows its content on-screen:
-
-```js run
-*!*
-// 1. Create a new XMLHttpRequest object
-*/!*
-let xhr = new XMLHttpRequest();
-
-*!*
-// 2. Configure it: GET-request for the URL /article/.../hello.txt
-xhr.open('GET', '/article/xmlhttprequest/hello.txt');
-*/!*
-
-*!*
-// 3. Send the request over the network
-*/!*
-xhr.send();
-
-*!*
-// 4. This will be called after the response is received
-*/!*
-xhr.onload = function() {
-  if (xhr.status != 200) { // analyze HTTP status of the response
-    // if it's not 200, consider it an error
-    alert(xhr.status + ': ' + xhr.statusText); // e.g. 404: Not Found
-  } else {
-    // show the result
-    alert(xhr.responseText); // responseText is the server response
-  }
-};
-```
-
-As we can see, there are several methods of `XMLHttpRequest` here. Let's cover them.
-
-## Setup: "open"
-
-The syntax:
-```js
-xhr.open(method, URL, async, user, password)
-```
-
-This method is usually called first after `new XMLHttpRequest`. It specifies the main parameters of the request:
-
-- `method` -- HTTP-method. Usually `"GET"` or `"POST"`, but we can also use TRACE/DELETE/PUT and so on.
-- `URL` -- the URL to request. Can use any path and protocol, but there are cross-domain limitations called "Same Origin Policy". We can make any requests to the same `protocol://domain:port` that the current page comes from, but other locations are "forbidden" by default (unless they implement special HTTP-headers, we'll cover them in chapter [todo]).
-- `async` -- if the third parameter is explicitly set to `false`, then the request is synchronous, otherwise it's asynchronous. We'll talk more about that in this chapter soon.
-- `user`, `password` -- login and password for basic HTTP auth (if required).
-
-Please note that `open` call, contrary to its name, does not open the connection. It only configures the request, but the network activity only starts with the call of `send`.
-
-## Send it out: "send"
-
-The syntax:
-```js
-xhr.send([body])
-```
-
-This method opens the connection and sends the request to server. The optional `body` parameter contains the request body. Some request methods like `GET` do not have a body. And some of them like `POST` use `body` to send the data. We'll see examples with a body in the next chapter.
-
-
-## Cancel: abort and timeout
-
-If we changed our mind, we can terminate the request at any time. The call to `xhr.abort()` does that:
-
-```js
-xhr.abort(); // terminate the request
-```
-
-We can also specify a timeout using the corresponding property:
-
-```js
-xhr.timeout = 10000;
-```
-
-The timeout is expressed in ms. If the request does not succeed within the given time, it gets canceled automatically.
-
-## Events: onload, onerror etc
-
-A request is asynchronous by default. In other words, the browser sends it out and allows other JavaScript code to execute.
-
-After the request is sent, `xhr` starts to generate events. We can use `addEventListener` or `on<event>` properties to handle them, just like with DOM objects.
-
-The modern [specification](https://xhr.spec.whatwg.org/#events) lists following events:
-
-- `loadstart` -- the request has started.
-- `progress` -- the browser received a data packet (can happen multiple times).
-- `abort` -- the request was aborted by `xhr.abort()`.
-- `error` -- an network error has occurred, the request failed.
-- `load` -- the request is successful, no errors.
-- `timeout` -- the request was canceled due to timeout (if the timeout is set).
-- `loadend` -- the request is done (with an error or without it)
-- `readystatechange` -- the request state is changed (will cover later).
-
-Using these events we can track successful loading (`onload`), errors (`onerror`) and the amount of the data loaded (`onprogress`).
-
-Please note that errors here are "communication errors". In other words, if the connection is lost or the remote server does not respond at all -- then it's the error in the terms of XMLHttpRequest. Bad HTTP status like 500 or 404 are not considered errors.
-
-Here's a more feature-full example, with errors and a timeout:
-
-```html run
-<script>
-  function load(url) {
-    let xhr = new XMLHttpRequest();
-    xhr.open('GET', url);
-    xhr.timeout = 1000;
-    xhr.send();
-
-    xhr.onload = function() {
-      alert(`Loaded: ${this.status} ${this.responseText}`);
-    };
-
-    xhr.onerror = () => alert('Error');
-
-    xhr.ontimeout = () => alert('Timeout!');
-  }
-</script>
-
-<button onclick="load('/article/xmlhttprequest/hello.txt')">Load</button>
-<button onclick="load('/article/xmlhttprequest/hello.txt?speed=0')">Load with timeout</button>
-<button onclick="load('no-such-page')">Load 404</button>
-<button onclick="load('http://example.com')">Load another domain</button>
-```
-
-1. The first button triggers only `onload` as it loads the file `hello.txt` normally.
-2. The second button loads a very slow URL, so it calls only `ontimeout` (because `xhr.timeout` is set).
-3. The third button loads a non-existant URL, but it also calls `onload` (with "Loaded: 404"), because there's no network error.
-4. The last button tries to load a page from another domain. That's prohibited unless the remote server explicitly agrees by sending certain headers (to be covered later), so we have `onerror` here. The `onerror` handler would also trigger in other cases if we start a request, and then sever the network connection of our device.
-
-## Response: status, responseText and others
-
-Once the server has responded, we can receive the result in the following properties of the request object:
-
-`status`
-: HTTP status code: `200`, `404`, `403` and so on. Also can be `0` if an error occurred.
-
-`statusText`
-: HTTP status message: usually `OK` for `200`, `Not Found` for `404`, `Forbidden` for `403` and so on.
-
-`responseText`
-: The text of the server response,
-
-If the server returns XML with the correct header `Content-type: text/xml`, then there's also `responseXML` property with the parsed XML document. You can query it with `xhr.responseXml.querySelector("...")` and perform other XML-specific operations.
-
-That's rarely used, because most of the time JSON is returned by the server. And then we can parse it using `JSON.parse(xhr.responseText)`.
-
-## Synchronous and asynchronous requests
-
-If in the `open` method the third parameter `async` is set to `false`, the request is made synchronously.
-
-In other words, Javascript execution pauses at that line and continues when the response is received. Somewhat like `alert` or `prompt` commands.
-
-Synchronous calls are used rarely, because they block in-page Javascript till the loading is complete. In some browsers, a user is unable to scroll the page.
-
-```js
-// Synchronous request
-xhr.open('GET', 'phones.json', *!*false*/!*);
-
-// Send it
-xhr.send();
-*!*
-// ...JavaScript "hangs" and waits till the request is complete
-*/!*
-```
-
-If a synchronous call takes too much time, the browser may suggest to close the "hanging" webpage.
-
-Also, because of the blocking, it becomes impossible to send two requests simultaneously. And, looking a bit forward, let's note that some advanced capabilities of `XMLHttpRequest`, like requesting from another domain or specifying a timeout, are unavailable for synchronous requests.
-
-Because of all that, synchronous requests are used very sparingly, almost never.
-
-By default, requests are asynchronous.
-
-The same request made asynchronously:
-
-```js
-let xhr = new XMLHttpRequest();
-
-xhr.open('GET', 'phones.json'); // the third parameter is true by default
-
-xhr.send(); // (1)
-
-*!*
-xhr.onreadystatechange = function() { // (3)
-  if (xhr.readyState != 4) return;
-*/!*
-
-  button.innerHTML = 'Complete!';
-
-  if (xhr.status != 200) {
-    alert(xhr.status + ': ' + xhr.statusText);
-  } else {
-    alert(xhr.responseText);
-  }
-
-}
-
-button.innerHTML = 'Loading...'; // (2)
-button.disabled = true;
-```
-
-Now as there's no third argument in `open` (or if we explicitly set it to `true`), the request is asynchronous. In other words, after the call `xhr.send()` in the line `(1)`, Javascript does not "hang", but continues to execute.
-
-In our case, it means that `(2)` shows a "loading" message.
-
-Then, after time, when the result is received, it comes in the event handler `(3)` that we'll cover a bit later.
-
-```online
-The full example in action:
-
-[codetabs src="phones-async"]
-```
-
-# Event "readystatechange"
-
-The event `readystatechange` occurs multiple times during sending the request and receiving the response.
-
-As the name suggests, there's a "ready state" of `XMLHttpRequest`. It is accessible as  `xhr.readyState`.
-
-In the example above we only used state `4` (request complete), but there are few more.
-
-All states, as in [the specification](http://www.w3.org/TR/XMLHttpRequest/#states):
-
-```js
-const unsigned short UNSENT = 0; // initial state
-const unsigned short OPENED = 1; // open called
-const unsigned short HEADERS_RECEIVED = 2; // response headers received
-const unsigned short LOADING = 3; // response is loading (a data packed is received)
-const unsigned short DONE = 4; // request complete
-```
-
-An `XMLHttpRequest` object travels them in the order `0` -> `1` -> `2` -> `3` -> ... -> `3` -> `4`. State `3` repeats every time a data packet is received over the network.
-
-The example above demonstrates these states. The server answers the request `digits` by sending a string of `1000` digits once per second.
-
-[codetabs src="readystate"]
-
-```warn header="Packets may break at any byte"
-One might think that `readyState=3` (the next data packet is received) allows us to get the current (not full yet) response body in `responseText`.
-
-That's true. But only partially.
-
-Technically, we do not have control over breakpoints between network packets. Many languages use multi-byte encodings like UTF-8, where a character is represented by multiple bytes. Some characters use only 1 byte, some use 2 or more. And packets may split *in the middle of a character*.
-
-E.g. the letter `ö` is encoded with two bytes. The first of them may be at the end of one packet, and the second one -- at the beginning of the next packet.
-
-So, during the `readyState`, at the end of `responseText` there will be a half-character byte. That may lead to problems. In some simple cases, when we use only latin characters and digits (they all are encoded with 1 byte), such thing can't happen, but in other cases, that can become a source of bugs.
-```
-
-## HTTP-headers
-
-`XMLHttpRequest` allows both to send custom headers and read headers from the response.
-
-There are 3 methods for HTTP-headers:
-
-`setRequestHeader(name, value)`
-: Sets the request header with the given `name` and `value`.
-
-    For instance:
-
-    ```js
-    xhr.setRequestHeader('Content-Type', 'application/json');
-    ```
-
-    ```warn header="Headers limitations"
-    Several headers are managed exclusively by the browser, e.g. `Referer` and `Host`.
-    The full list is [in the specification](http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader-method).
-
-    XMLHttpRequest is not allowed to change them, for the sake of user safety and correctness of the request.
-    ```
-
-    ````warn header="Can't remove a header"
-    Another peciliarity of `XMLHttpRequest` is that one can't undo `setRequestHeader`.
-
-    Once the header is set, it's set. Additional calls add information to the header, don't overwrite it.
-
-    For instance:
-
-    ```js
-    xhr.setRequestHeader('X-Auth', '123');
-    xhr.setRequestHeader('X-Auth', '456');
-
-    // the header will be:
-    // X-Auth: 123, 456
-    ```
-    ````
-
-`getResponseHeader(name)`
-: Gets the response header with the given `name` (except `Set-Cookie` and `Set-Cookie2`).
-
-    For instance:
-
-    ```js
-    xhr.getResponseHeader('Content-Type')
-    ```
-
-`getAllResponseHeaders()`
-: Returns all response headers, except `Set-Cookie` and `Set-Cookie2`.
-
-    Headers are returned as a single line, e.g.:
-
-    ```
-    Cache-Control: max-age=31536000
-    Content-Length: 4260
-    Content-Type: image/png
-    Date: Sat, 08 Sep 2012 16:53:16 GMT
-    ```
-
-    The line break between headers is always `"\r\n"` (doesn't depend on OS), so we can easily split it into individual headers. The separator between the name and the value is always a colon followed by a space `": "`. That's fixed in the specification.
-
-    So, if we want to get an object with name/value pairs, we need to throw in a bit JS.
-
-    Like this (assuming that if two headers have the same name, then the latter one overwrites the former one):
-
-    ```js
-    let headers = xhr
-      .getAllResponseHeaders()
-      .split('\r\n')
-      .reduce((result, current) => {
-        let [name, value] = current.split(': ');
-        result[name] = value;
-        return acc;
-      }, {});
-    ```
-
-
-## Timeout
-
-The maximum duration of an asynchronous request can be set using the `timeout` property:
-
-```js
-xhr.timeout = 30000; // 30 seconds (in milliseconds)
-```
-
-If the request exceeds that time, it's aborted, and the `timeout` event is generated:
-
-```js
-xhr.ontimeout = function() {
-  alert( 'Sorry, the request took too long.' );
-}
-```
-
-## The full event list
-
-The [modern specification](http://www.w3.org/TR/XMLHttpRequest/#events) lists following events (in the lifecycle order):
-
-- `loadstart` -- the request has started.
-- `progress` -- a data packet of the response has arrived, the whole response body at the moment is in `responseText`.
-- `abort` -- the request was canceled by the call `xhr.abort()`.
-- `error` -- connection error has occured, e.g. wrong domain name. Doesn't happen for HTTP-errors like 404.
-- `load` -- the request has finished successfully.
-- `timeout` -- the request was canceled due to timeout (only happens if it was set).
-- `loadend` -- the request has finished (succeffully or not).
-
-The most used events are load completion (`onload`), load failure (`onerror`), and also `onprogress` to track the progress.
-
-We've already seen another event: `readystatechange`. Historically, it appeared long ago, before the specification settled. Nowadays, there's no need to use it, we can replace it with newer events, but it can often be found in older scripts.
-
-## Summary
-
-Typical code of the GET-request with `XMLHttpRequest`:
-
-```js
-let xhr = new XMLHttpRequest();
-
-xhr.open('GET', '/my/url');
-
-xhr.send();
-
-xhr.onload = function() {
-  // we can check
-  // status, statusText - for response HTTP status
-  // responseText, responseXML (when content-type: text/xml) - for the response
-
-  if (this.status != 200) {
-    // handle error
-    alert( 'error: ' + this.status);
-    return;
-  }
-
-  // get the response from this.responseText
-};
-
-xhr.onerror = function() {
-  // handle error
-};
-```
-
-XMLHttpRequest is widely used, but there's a more modern method named `fetch(url)` that returns a promise, thus working well with async/await. We'll cover it soon in the next sections.
diff --git a/7-network/1-xmlhttprequest/readystate.view/index.html b/7-network/1-xmlhttprequest/readystate.view/index.html
deleted file mode 100644
index d9f32ced9..000000000
--- a/7-network/1-xmlhttprequest/readystate.view/index.html
+++ /dev/null
@@ -1,35 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<head>
-  <meta charset="utf-8">
-</head>
-<body>
-
-  <button onclick="run()">Load digits</button>
-
-  <ul id="log"></ul>
-
-  <script>
-    function run() {
-
-      let xhr = new XMLHttpRequest();
-      write(xhr.readyState);
-
-      xhr.open('GET', 'digits', true);
-      write(xhr.readyState);
-
-      xhr.onreadystatechange = function() {
-        write(xhr.readyState + " responseText length:" + xhr.responseText.length);
-      };
-
-      xhr.send();
-    }
-
-    function write(text) {
-      let li = log.appendChild(document.createElement('li'));
-      li.innerHTML = text;
-    }
-  </script>
-
-</body>
-</html>
diff --git a/7-network/1-xmlhttprequest/readystate.view/server.js b/7-network/1-xmlhttprequest/readystate.view/server.js
deleted file mode 100644
index 63b01a021..000000000
--- a/7-network/1-xmlhttprequest/readystate.view/server.js
+++ /dev/null
@@ -1,42 +0,0 @@
-var http = require('http');
-var url = require('url');
-var querystring = require('querystring');
-var static = require('node-static');
-var file = new static.Server('.');
-
-function accept(req, res) {
-
-  if (req.url == '/digits') {
-
-    res.writeHead(200, {
-      'Content-Type': 'text/plain',
-      'Cache-Control': 'no-cache'
-    });
-
-    var i = 0;
-
-    var timer = setInterval(write, 1000);
-    write();
-
-    function write() {
-      res.write(new Array(1000).join(++i + '') + ' ');
-      if (i == 9) {
-        clearInterval(timer);
-        res.end();
-      }
-
-    }
-  } else {
-    file.serve(req, res);
-  }
-}
-
-
-
-// ----- запуск accept как сервера из консоли или как модуля ------
-
-if (!module.parent) {
-  http.createServer(accept).listen(8080);
-} else {
-  exports.accept = accept;
-}
\ No newline at end of file
diff --git a/7-network/index.md b/7-network/index.md
deleted file mode 100644
index 1ee6a3e55..000000000
--- a/7-network/index.md
+++ /dev/null
@@ -1,5 +0,0 @@
-development: true
-
----
-
-# Network requests: AJAX and COMET
diff --git a/8-web-components/1-webcomponents-intro/article.md b/8-web-components/1-webcomponents-intro/article.md
new file mode 100644
index 000000000..e3e175f49
--- /dev/null
+++ b/8-web-components/1-webcomponents-intro/article.md
@@ -0,0 +1,75 @@
+# From the orbital height
+
+This section describes a set of modern standards for "web components".
+
+As of now, these standards are under development. Some features are well-supported and integrated into the modern HTML/DOM standard, while others are yet in draft stage. You can try examples in any browser, Google Chrome is probably the most up to date with these features. Guess, that's because Google fellows are behind many of the related specifications.
+
+## What's common between...
+
+The whole component idea is nothing new. It's used in many frameworks and elsewhere.
+
+Before we move to implementation details, take a look at this great achievement of humanity:
+
+![](satellite.jpg)
+
+That's the International Space Station (ISS).
+
+And this is how it's made inside (approximately):
+
+![](satellite-expanded.jpg)
+
+The International Space Station:
+- Consists of many components.
+- Each component, in its turn, has many smaller details inside.
+- The components are very complex, much more complicated than most websites.
+- Components are developed internationally, by teams from different countries, speaking different languages.
+
+...And this thing flies, keeps humans alive in space!
+
+How such complex devices are created?
+
+Which principles we could borrow to make our development same-level reliable and scalable? Or, at least, close to it.
+
+## Component architecture
+
+The well known rule for developing complex software is: don't make complex software.
+
+If something becomes complex -- split it into simpler parts and connect in the most obvious way.
+
+**A good architect is the one who can make the complex simple.**
+
+We can split user interface into visual components: each of them has own place on the page, can "do" a well-described task, and is separate from the others.
+
+Let's take a look at a website, for example Twitter.
+
+It naturally splits into components:
+
+![](web-components-twitter.png)
+
+1. Top navigation.
+2. User info.
+3. Follow suggestions.
+4. Submit form.
+5. (and also 6, 7) -- messages.
+
+Components may have subcomponents, e.g. messages may be parts of a higher-level "message list" component. A clickable user picture itself may be a component, and so on.
+
+How do we decide, what is a component? That comes from intuition, experience and common sense. Usually it's a separate visual entity that we can describe in terms of what it does and how it interacts with the page. In the case above, the page has blocks, each of them plays its own role, it's logical to make these components.
+
+- A component has its own JavaScript class.
+- DOM structure, managed solely by its class, outside code doesn't access it ("encapsulation" principle).
+- CSS styles, applied to the component.
+- API: events, class methods etc, to interact with other components.
+
+Once again, the whole "component" thing is nothing special.
+
+There exist many frameworks and development methodologies to build them, each one with its own bells and whistles. Usually, special CSS classes and conventions are used to provide "component feel" -- CSS scoping and DOM encapsulation.
+
+"Web components" provide built-in browser capabilities for that, so we don't have to emulate them any more.
+
+- [Custom elements](https://html.spec.whatwg.org/multipage/custom-elements.html#custom-elements) -- to define custom HTML elements.
+- [Shadow DOM](https://dom.spec.whatwg.org/#shadow-trees) -- to create an internal DOM for the component, hidden from the others.
+- [CSS Scoping](https://drafts.csswg.org/css-scoping/) -- to declare styles that only apply inside the Shadow DOM of the component.
+- [Event retargeting](https://dom.spec.whatwg.org/#retarget) and other minor stuff to make custom components better fit the development.
+
+In the next chapter we'll go into details of "Custom Elements" -- the fundamental and well-supported feature of web components, good on its own.
diff --git a/8-web-components/1-webcomponents-intro/satellite-expanded.jpg b/8-web-components/1-webcomponents-intro/satellite-expanded.jpg
new file mode 100644
index 000000000..56c127112
Binary files /dev/null and b/8-web-components/1-webcomponents-intro/satellite-expanded.jpg differ
diff --git a/8-web-components/1-webcomponents-intro/satellite-expanded@2x.jpg b/8-web-components/1-webcomponents-intro/satellite-expanded@2x.jpg
new file mode 100644
index 000000000..c65b12450
Binary files /dev/null and b/8-web-components/1-webcomponents-intro/satellite-expanded@2x.jpg differ
diff --git a/8-web-components/1-webcomponents-intro/satellite.jpg b/8-web-components/1-webcomponents-intro/satellite.jpg
new file mode 100644
index 000000000..9a3793f35
Binary files /dev/null and b/8-web-components/1-webcomponents-intro/satellite.jpg differ
diff --git a/8-web-components/1-webcomponents-intro/satellite@2x.jpg b/8-web-components/1-webcomponents-intro/satellite@2x.jpg
new file mode 100644
index 000000000..9624379d5
Binary files /dev/null and b/8-web-components/1-webcomponents-intro/satellite@2x.jpg differ
diff --git a/8-web-components/1-webcomponents-intro/web-components-twitter.png b/8-web-components/1-webcomponents-intro/web-components-twitter.png
new file mode 100644
index 000000000..9d59650c0
Binary files /dev/null and b/8-web-components/1-webcomponents-intro/web-components-twitter.png differ
diff --git a/8-web-components/1-webcomponents-intro/web-components-twitter@2x.png b/8-web-components/1-webcomponents-intro/web-components-twitter@2x.png
new file mode 100644
index 000000000..5abd4a2d8
Binary files /dev/null and b/8-web-components/1-webcomponents-intro/web-components-twitter@2x.png differ
diff --git a/8-web-components/2-custom-elements/1-live-timer/solution.md b/8-web-components/2-custom-elements/1-live-timer/solution.md
new file mode 100644
index 000000000..a9eacc880
--- /dev/null
+++ b/8-web-components/2-custom-elements/1-live-timer/solution.md
@@ -0,0 +1,4 @@
+
+Please note:
+1. We clear `setInterval` timer when the element is removed from the document. That's important, otherwise it continues ticking even if not needed any more. And the browser can't clear the memory from this element and referenced by it.
+2. We can access current date as `elem.date` property. All class methods and properties are naturally element methods and properties.
diff --git a/8-web-components/2-custom-elements/1-live-timer/solution.view/index.html b/8-web-components/2-custom-elements/1-live-timer/solution.view/index.html
new file mode 100644
index 000000000..e1dd85096
--- /dev/null
+++ b/8-web-components/2-custom-elements/1-live-timer/solution.view/index.html
@@ -0,0 +1,9 @@
+<!doctype html>
+<script src="time-formatted.js"></script>
+<script src="live-timer.js"></script>
+
+<live-timer id="elem"></live-timer>
+
+<script>
+  elem.addEventListener('tick', event => console.log(event.detail));
+</script>
diff --git a/8-web-components/2-custom-elements/1-live-timer/solution.view/live-timer.js b/8-web-components/2-custom-elements/1-live-timer/solution.view/live-timer.js
new file mode 100644
index 000000000..a53d72e00
--- /dev/null
+++ b/8-web-components/2-custom-elements/1-live-timer/solution.view/live-timer.js
@@ -0,0 +1,32 @@
+class LiveTimer extends HTMLElement {
+
+  render() {
+    this.innerHTML = `
+    <time-formatted hour="numeric" minute="numeric" second="numeric">
+    </time-formatted>
+    `;
+
+    this.timerElem = this.firstElementChild;
+  }
+
+  connectedCallback() { // (2)
+    if (!this.rendered) {
+      this.render();
+      this.rendered = true;
+    }
+    this.timer = setInterval(() => this.update(), 1000);
+  }
+
+  update() {
+    this.date = new Date();
+    this.timerElem.setAttribute('datetime', this.date);
+    this.dispatchEvent(new CustomEvent('tick', { detail: this.date }));
+  }
+
+  disconnectedCallback() {
+    clearInterval(this.timer); // important to let the element be garbage-collected
+  }
+
+}
+
+customElements.define("live-timer", LiveTimer);
diff --git a/8-web-components/2-custom-elements/1-live-timer/solution.view/time-formatted.js b/8-web-components/2-custom-elements/1-live-timer/solution.view/time-formatted.js
new file mode 100644
index 000000000..4fab99cb2
--- /dev/null
+++ b/8-web-components/2-custom-elements/1-live-timer/solution.view/time-formatted.js
@@ -0,0 +1,34 @@
+class TimeFormatted extends HTMLElement {
+
+  render() {
+    let date = new Date(this.getAttribute('datetime') || Date.now());
+
+    this.innerHTML = new Intl.DateTimeFormat("default", {
+      year: this.getAttribute('year') || undefined,
+      month: this.getAttribute('month') || undefined,
+      day: this.getAttribute('day') || undefined,
+      hour: this.getAttribute('hour') || undefined,
+      minute: this.getAttribute('minute') || undefined,
+      second: this.getAttribute('second') || undefined,
+      timeZoneName: this.getAttribute('time-zone-name') || undefined,
+    }).format(date);
+  }
+
+  connectedCallback() {
+    if (!this.rendered) {
+      this.render();
+      this.rendered = true;
+    }
+  }
+
+  static get observedAttributes() {
+    return ['datetime', 'year', 'month', 'day', 'hour', 'minute', 'second', 'time-zone-name'];
+  }
+
+  attributeChangedCallback(name, oldValue, newValue) { 
+    this.render();
+  }
+
+}
+
+customElements.define("time-formatted", TimeFormatted);
diff --git a/8-web-components/2-custom-elements/1-live-timer/source.view/index.html b/8-web-components/2-custom-elements/1-live-timer/source.view/index.html
new file mode 100644
index 000000000..878120241
--- /dev/null
+++ b/8-web-components/2-custom-elements/1-live-timer/source.view/index.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<!-- don't modify this -->
+<script src="time-formatted.js"></script>
+
+<!-- your code here: -->
+<script src="live-timer.js"></script>
+
+<live-timer id="elem"></live-timer>
+
+<script>
+  elem.addEventListener('tick', event => console.log(event.detail));
+</script>
diff --git a/8-web-components/2-custom-elements/1-live-timer/source.view/live-timer.js b/8-web-components/2-custom-elements/1-live-timer/source.view/live-timer.js
new file mode 100644
index 000000000..e2fe2b69f
--- /dev/null
+++ b/8-web-components/2-custom-elements/1-live-timer/source.view/live-timer.js
@@ -0,0 +1,7 @@
+class LiveTimer extends HTMLElement {
+
+  /* your code here */
+
+}
+
+customElements.define("live-timer", LiveTimer);
diff --git a/8-web-components/2-custom-elements/1-live-timer/source.view/time-formatted.js b/8-web-components/2-custom-elements/1-live-timer/source.view/time-formatted.js
new file mode 100644
index 000000000..4fab99cb2
--- /dev/null
+++ b/8-web-components/2-custom-elements/1-live-timer/source.view/time-formatted.js
@@ -0,0 +1,34 @@
+class TimeFormatted extends HTMLElement {
+
+  render() {
+    let date = new Date(this.getAttribute('datetime') || Date.now());
+
+    this.innerHTML = new Intl.DateTimeFormat("default", {
+      year: this.getAttribute('year') || undefined,
+      month: this.getAttribute('month') || undefined,
+      day: this.getAttribute('day') || undefined,
+      hour: this.getAttribute('hour') || undefined,
+      minute: this.getAttribute('minute') || undefined,
+      second: this.getAttribute('second') || undefined,
+      timeZoneName: this.getAttribute('time-zone-name') || undefined,
+    }).format(date);
+  }
+
+  connectedCallback() {
+    if (!this.rendered) {
+      this.render();
+      this.rendered = true;
+    }
+  }
+
+  static get observedAttributes() {
+    return ['datetime', 'year', 'month', 'day', 'hour', 'minute', 'second', 'time-zone-name'];
+  }
+
+  attributeChangedCallback(name, oldValue, newValue) { 
+    this.render();
+  }
+
+}
+
+customElements.define("time-formatted", TimeFormatted);
diff --git a/8-web-components/2-custom-elements/1-live-timer/task.md b/8-web-components/2-custom-elements/1-live-timer/task.md
new file mode 100644
index 000000000..1feb7490a
--- /dev/null
+++ b/8-web-components/2-custom-elements/1-live-timer/task.md
@@ -0,0 +1,23 @@
+
+# Live timer element
+
+We already have `<time-formatted>` element to show a nicely formatted time.
+
+Create `<live-timer>` element to show the current time:
+1. It should use `<time-formatted>` internally, not duplicate its functionality.
+2. Ticks (updates) every second.
+3. For every tick, a custom event named `tick` should be generated, with the current date in `event.detail` (see chapter <info:dispatch-events>).
+
+Usage:
+
+```html
+<live-timer id="elem"></live-timer>
+
+<script>
+  elem.addEventListener('tick', event => console.log(event.detail));
+</script>
+```
+
+Demo:
+
+[iframe src="solution" height=40]
diff --git a/8-web-components/2-custom-elements/article.md b/8-web-components/2-custom-elements/article.md
new file mode 100644
index 000000000..85434c75a
--- /dev/null
+++ b/8-web-components/2-custom-elements/article.md
@@ -0,0 +1,399 @@
+
+# Custom elements
+
+We can create custom HTML elements, described by our class, with its own methods and properties, events and so on.
+
+Once an custom element is defined, we can use it on par with built-in HTML elements.
+
+That's great, as HTML dictionary is rich, but not infinite. There are no `<easy-tabs>`, `<sliding-carousel>`, `<beautiful-upload>`... Just think of any other tag we might need.
+
+We can define them with a special class, and then use as if they were always a part of HTML.
+
+There are two kinds of custom elements:
+
+1. **Autonomous custom elements** -- "all-new" elements, extending the abstract `HTMLElement` class.
+2. **Customized built-in elements** -- extending built-in elements, like customized `HTMLButtonElement` etc.
+
+First we'll create autonomous elements, and then customized built-in ones.
+
+To create a custom element, we need to tell the browser several details about it: how to show it, what to do when the element is added or removed to page, etc.
+
+That's done by making a class with special methods. That's easy, as there are only few methods, and all of them are optional.
+
+Here's a sketch with the full list:
+
+```js
+class MyElement extends HTMLElement {
+  constructor() {
+    super();
+    // element created
+  }
+
+  connectedCallback() {
+    // browser calls it when the element is added to the document
+    // (can be called many times if an element is repeatedly added/removed)
+  }
+
+  disconnectedCallback() {
+    // browser calls it when the element is removed from the document
+    // (can be called many times if an element is repeatedly added/removed)
+  }
+
+  static get observedAttributes() {
+    return [/* array of attribute names to monitor for changes */];
+  }
+
+  attributeChangedCallback(name, oldValue, newValue) {
+    // called when one of attributes listed above is modified
+  }
+
+  adoptedCallback() {
+    // called when the element is moved to a new document
+    // (happens in document.adoptNode, very rarely used)
+  }
+
+  // there can be other element methods and properties
+}
+```
+
+After that, we need to register the element:
+
+```js
+// let the browser know that <my-element> is served by our new class
+customElements.define("my-element", MyElement);
+```
+
+Now for any HTML elements with tag `<my-element>`, an instance of `MyElement` is created, and the aforementioned methods are called. We also can `document.createElement('my-element')` in JavaScript.
+
+```smart header="Custom element name must contain a hyphen `-`"
+Custom element name must have a hyphen `-`, e.g. `my-element` and `super-button` are valid names, but `myelement` is not.
+
+That's to ensure that there are no name conflicts between built-in and custom HTML elements.
+```
+
+## Example: "time-formatted"
+
+For example, there already exists `<time>` element in HTML, for date/time. But it doesn't do any formatting by itself.
+
+Let's create `<time-formatted>` element that displays the time in a nice, language-aware format:
+
+
+```html run height=50 autorun="no-epub"
+<script>
+*!*
+class TimeFormatted extends HTMLElement { // (1)
+*/!*
+
+  connectedCallback() {
+    let date = new Date(this.getAttribute('datetime') || Date.now());
+
+    this.innerHTML = new Intl.DateTimeFormat("default", {
+      year: this.getAttribute('year') || undefined,
+      month: this.getAttribute('month') || undefined,
+      day: this.getAttribute('day') || undefined,
+      hour: this.getAttribute('hour') || undefined,
+      minute: this.getAttribute('minute') || undefined,
+      second: this.getAttribute('second') || undefined,
+      timeZoneName: this.getAttribute('time-zone-name') || undefined,
+    }).format(date);
+  }
+
+}
+
+*!*
+customElements.define("time-formatted", TimeFormatted); // (2)
+*/!*
+</script>
+
+<!-- (3) -->
+*!*
+<time-formatted datetime="2019-12-01"
+*/!*
+  year="numeric" month="long" day="numeric"
+  hour="numeric" minute="numeric" second="numeric"
+  time-zone-name="short"
+></time-formatted>
+```
+
+1. The class has only one method `connectedCallback()` -- the browser calls it when `<time-formatted>` element is added to page (or when HTML parser detects it), and it uses the built-in [Intl.DateTimeFormat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat) data formatter, well-supported across the browsers, to show a nicely formatted time.
+2. We need to register our new element by `customElements.define(tag, class)`.
+3. And then we can use it everywhere.
+
+
+```smart header="Custom elements upgrade"
+If the browser encounters any `<time-formatted>` elements before `customElements.define`, that's not an error. But the element is yet unknown, just like any non-standard tag.
+
+Such "undefined" elements can be styled with CSS selector `:not(:defined)`.
+
+When `customElement.define` is called, they are "upgraded": a new instance of `TimeFormatted`
+is created for each, and `connectedCallback` is called. They become `:defined`.
+
+To get the information about custom elements, there are methods:
+- `customElements.get(name)` -- returns the class for a custom element with the given `name`,
+- `customElements.whenDefined(name)` -- returns a promise that resolves (without value) when a custom element with the given `name` becomes defined.
+```
+
+```smart header="Rendering in `connectedCallback`, not in `constructor`"
+In the example above, element content is rendered (created) in `connectedCallback`.
+
+Why not in the `constructor`?
+
+The reason is simple: when `constructor` is called, it's yet too early. The element instance is created, but not populated yet. The browser did not yet process/assign attributes at this stage: calls to `getAttribute` would return `null`. So we can't really render there.
+
+Besides, if you think about it, that's better performance-wise -- to delay the work until it's really needed.
+
+The `connectedCallback` triggers when the element is added to the document. Not just appended to another element as a child, but actually becomes a part of the page. So we can build detached DOM, create elements and prepare them for later use. They will only be actually rendered when they make it into the page.
+```
+
+## Observing attributes
+
+In the current implementation of `<time-formatted>`, after the element is rendered, further attribute changes don't have any effect. That's strange for an HTML element. Usually, when we change an attribute, like `a.href`, we expect the change to be immediately visible. So let's fix this.
+
+We can observe attributes by providing their list in `observedAttributes()` static getter. For such attributes, `attributeChangedCallback` is called when they are modified. It doesn't trigger for an attribute for performance reasons.
+
+Here's a new `<time-formatted>`, that auto-updates when attributes change:
+
+```html run autorun="no-epub" height=50
+<script>
+class TimeFormatted extends HTMLElement {
+
+*!*
+  render() { // (1)
+*/!*
+    let date = new Date(this.getAttribute('datetime') || Date.now());
+
+    this.innerHTML = new Intl.DateTimeFormat("default", {
+      year: this.getAttribute('year') || undefined,
+      month: this.getAttribute('month') || undefined,
+      day: this.getAttribute('day') || undefined,
+      hour: this.getAttribute('hour') || undefined,
+      minute: this.getAttribute('minute') || undefined,
+      second: this.getAttribute('second') || undefined,
+      timeZoneName: this.getAttribute('time-zone-name') || undefined,
+    }).format(date);
+  }
+
+*!*
+  connectedCallback() { // (2)
+*/!*
+    if (!this.rendered) {
+      this.render();
+      this.rendered = true;
+    }
+  }
+
+*!*
+  static get observedAttributes() { // (3)
+*/!*
+    return ['datetime', 'year', 'month', 'day', 'hour', 'minute', 'second', 'time-zone-name'];
+  }
+
+*!*
+  attributeChangedCallback(name, oldValue, newValue) { // (4)
+*/!*
+    this.render();
+  }
+
+}
+
+customElements.define("time-formatted", TimeFormatted);
+</script>
+
+<time-formatted id="elem" hour="numeric" minute="numeric" second="numeric"></time-formatted>
+
+<script>
+*!*
+setInterval(() => elem.setAttribute('datetime', new Date()), 1000); // (5)
+*/!*
+</script>
+```
+
+1. The rendering logic is moved to `render()` helper method.
+2. We call it once when the element is inserted into page.
+3. For a change of an attribute, listed in `observedAttributes()`, `attributeChangedCallback` triggers.
+4. ...and re-renders the element.
+5. At the end, we can easily make a live timer.
+
+## Rendering order
+
+When HTML parser builds the DOM, elements are processed one after another, parents before children. E.g. if we have `<outer><inner></inner></outer>`, then `<outer>` element is created and connected to DOM first, and then `<inner>`.
+
+That leads to important consequences for custom elements.
+
+For example, if a custom element tries to access `innerHTML` in `connectedCallback`, it gets nothing:
+
+```html run height=40
+<script>
+customElements.define('user-info', class extends HTMLElement {
+
+  connectedCallback() {
+*!*
+    alert(this.innerHTML); // empty (*)
+*/!*
+  }
+
+});
+</script>
+
+*!*
+<user-info>John</user-info>
+*/!*
+```
+
+If you run it, the `alert` is empty.
+
+That's exactly because there are no children on that stage, the DOM is unfinished. HTML parser connected the custom element `<user-info>`, and will now proceed to its children, but just didn't yet.
+
+If we'd like to pass information to custom element, we can use attributes. They are available immediately.
+
+Or, if we really need the children, we can defer access to them with zero-delay `setTimeout`.
+
+This works:
+
+```html run height=40
+<script>
+customElements.define('user-info', class extends HTMLElement {
+
+  connectedCallback() {
+*!*
+    setTimeout(() => alert(this.innerHTML)); // John (*)
+*/!*
+  }
+
+});
+</script>
+
+*!*
+<user-info>John</user-info>
+*/!*
+```
+
+Now the `alert` in line `(*)` shows "John", as we run it asynchronously, after the HTML parsing is complete. We can process children if needed and finish the initialization.
+
+On the other hand, this solution is also not perfect. If nested custom elements also use `setTimeout` to initialize themselves, then they queue up: the outer `setTimeout` triggers first, and then the inner one.
+
+So the outer element finishes the initialization before the inner one.
+
+Let's demonstrate that on example:
+
+```html run height=0
+<script>
+customElements.define('user-info', class extends HTMLElement {
+  connectedCallback() {
+    alert(`${this.id} connected.`);
+    setTimeout(() => alert(`${this.id} initialized.`));
+  }
+});
+</script>
+
+*!*
+<user-info id="outer">
+  <user-info id="inner"></user-info>
+</user-info>
+*/!*
+```
+
+Output order:
+
+1. outer connected.
+2. inner connected.
+2. outer initialized.
+4. inner initialized.
+
+We can clearly see that the outer element does not wait for the inner one.
+
+There's no built-in callback that triggers after nested elements are ready. But we can implement such thing on our own. For instance, inner elements can dispatch events like `initialized`, and outer ones can listen and react on them.
+
+## Customized built-in elements
+
+New elements that we create, such as `<time-formatted>`, don't have any associated semantics. They are unknown to search engines, and accessibility devices can't handle them.
+
+But such things can be important. E.g, a search engine would be interested to know that we actually show a time. And if we're making a special kind of button, why not reuse the existing `<button>` functionality?
+
+We can extend and customize built-in elements by inheriting from their classes.
+
+For example, buttons are instances of `HTMLButtonElement`, let's build upon it.
+
+1. Extend `HTMLButtonElement` with our class:
+
+    ```js
+    class HelloButton extends HTMLButtonElement { /* custom element methods */ }
+    ```
+
+2. Provide an third argument to `customElements.define`, that specifies the tag:
+    ```js
+    customElements.define('hello-button', HelloButton, *!*{extends: 'button'}*/!*);
+    ```    
+    There exist different tags that share the same class, that's why it's needed.
+
+3. At the end, to use our custom element, insert a regular `<button>` tag, but add `is="hello-button"` to it:
+    ```html
+    <button is="hello-button">...</button>
+    ```
+
+Here's a full example:
+
+```html run autorun="no-epub"
+<script>
+// The button that says "hello" on click
+class HelloButton extends HTMLButtonElement {
+*!*
+  constructor() {
+*/!*
+    super();
+    this.addEventListener('click', () => alert("Hello!"));
+  }
+}
+
+*!*
+customElements.define('hello-button', HelloButton, {extends: 'button'});
+*/!*
+</script>
+
+*!*
+<button is="hello-button">Click me</button>
+*/!*
+
+*!*
+<button is="hello-button" disabled>Disabled</button>
+*/!*
+```
+
+Our new button extends the built-in one. So it keeps the same styles and standard features like `disabled` attribute.
+
+## References
+
+- HTML Living Standard: <https://html.spec.whatwg.org/#custom-elements>.
+- Compatiblity: <https://caniuse.com/#feat=custom-elements>.
+
+## Summary
+
+Custom elements can be of two types:
+
+1. "Autonomous" -- new tags, extending `HTMLElement`.
+
+    Definition scheme:
+
+    ```js
+    class MyElement extends HTMLElement {
+      constructor() { super(); /* ... */ }
+      connectedCallback() { /* ... */ }
+      disconnectedCallback() { /* ... */  }
+      static get observedAttributes() { return [/* ... */]; }
+      attributeChangedCallback(name, oldValue, newValue) { /* ... */ }
+      adoptedCallback() { /* ... */ }
+     }
+    customElements.define('my-element', MyElement);
+    /* <my-element> */
+    ```
+
+2. "Customized built-in elements" -- extensions of existing elements.
+
+    Requires one more `.define` argument, and `is="..."` in HTML:
+    ```js
+    class MyButton extends HTMLButtonElement { /*...*/ }
+    customElements.define('my-button', MyElement, {extends: 'button'});
+    /* <button is="my-button"> */
+    ```
+
+Custom elements are well-supported among browsers. Edge is a bit behind, but there's a polyfill <https://github.com/webcomponents/webcomponentsjs>.
diff --git a/8-web-components/2-custom-elements/head.html b/8-web-components/2-custom-elements/head.html
new file mode 100644
index 000000000..c07cb6d43
--- /dev/null
+++ b/8-web-components/2-custom-elements/head.html
@@ -0,0 +1,38 @@
+<script>
+  /*
+class TimeFormatted extends HTMLElement {
+
+  render() {
+    let date = new Date(this.getAttribute('datetime') || Date.now());
+
+    this.innerHTML = new Intl.DateTimeFormat("default", {
+      year: this.getAttribute('year') || undefined,
+      month: this.getAttribute('month') || undefined,
+      day: this.getAttribute('day') || undefined,
+      hour: this.getAttribute('hour') || undefined,
+      minute: this.getAttribute('minute') || undefined,
+      second: this.getAttribute('second') || undefined,
+      timeZoneName: this.getAttribute('time-zone-name') || undefined,
+    }).format(date);
+  }
+
+  connectedCallback() { // (2)
+    if (!this.rendered) {
+      this.render();
+      this.rendered = true;
+    }
+  }
+
+  static get observedAttributes() { // (3)
+    return ['datetime', 'year', 'month', 'day', 'hour', 'minute', 'second', 'time-zone-name'];
+  }
+
+  attributeChangedCallback(name, oldValue, newValue) { // (4)
+    this.render();
+  }
+
+}
+
+window.customElements && customElements.define("time-formatted", TimeFormatted);
+*/
+</script>
diff --git a/8-web-components/3-shadow-dom/article.md b/8-web-components/3-shadow-dom/article.md
new file mode 100644
index 000000000..7a58dddb3
--- /dev/null
+++ b/8-web-components/3-shadow-dom/article.md
@@ -0,0 +1,157 @@
+# Shadow DOM
+
+Shadow DOM serves for encapsulation. It allows a component to have its very own "shadow" DOM tree, that can't be accidentally accessed from the main document, may have local style rules, and more.
+
+## Built-in shadow DOM
+
+Did you ever think how complex browser controls are created and styled?
+
+Such as `<input type="range">`:
+
+<p>
+<input type="range">
+</p>
+
+The browser uses DOM/CSS internally to draw them. That DOM structure is normally hidden from us, but we can see it in developer tools. E.g. in Chrome, we need to enable in Dev Tools "Show user agent shadow DOM" option.
+
+Then `<input type="range">` looks like this:
+
+![](shadow-dom-range.png)
+
+What you see under `#shadow-root` is called "shadow DOM".
+
+We can't get built-in shadow DOM elements by regular JavaScript calls or selectors. These are not regular children, but a powerful encapsulation technique.
+
+In the example above, we can see a useful attribute `pseudo`. It's non-standard, exists for historical reasons. We can use it style subelements with CSS, like this:
+
+```html run autorun
+<style>
+/* make the slider track red */
+input::-webkit-slider-runnable-track {
+  background: red;
+}
+</style>
+
+<input type="range">
+```
+
+Once again, `pseudo` is a non-standard attribute. Chronologically, browsers first started to experiment with internal DOM structures to implement controls, and then, after time, shadow DOM was standartized to allow us, developers, to do the similar thing.
+
+Furhter on, we'll use the modern shadow DOM standard, covered by [DOM spec](https://dom.spec.whatwg.org/#shadow-trees) other related specifications.
+
+## Shadow tree
+
+A DOM element can have two types of DOM subtrees:
+
+1. Light tree -- a regular DOM subtree, made of HTML children. All subtrees that we've seen in previous chapters were "light".
+2. Shadow tree -- a hidden DOM subtree, not reflected in HTML, hidden from prying eyes.
+
+If an element has both, then the browser renders only the shadow tree. But we can setup a kind of composition between shadow and light trees as well. We'll see the details later in the chapter <info:slots-composition>.
+
+Shadow tree can be used in Custom Elements to hide component internals and apply component-local styles.
+
+For example, this `<show-hello>` element hides its internal DOM in shadow tree:
+
+```html run autorun height=60
+<script>
+customElements.define('show-hello', class extends HTMLElement {
+  connectedCallback() {
+    const shadow = this.attachShadow({mode: 'open'});
+    shadow.innerHTML = `<p>
+      Hello, ${this.getAttribute('name')}
+    </p>`;
+  }  
+});
+</script>
+
+<show-hello name="John"></show-hello>
+```
+
+That's how the resulting DOM looks in Chrome dev tools, all the content is under "#shadow-root":
+
+![](shadow-dom-say-hello.png)
+
+First, the call to `elem.attachShadow({mode: …})` creates a shadow tree.
+
+There are two limitations:
+1. We can create only one shadow root per element.
+2. The `elem` must be either a custom element, or one of: "article", "aside", "blockquote", "body", "div", "footer", "h1..h6", "header", "main" "nav", "p", "section", or "span". Other elements, like `<img>`, can't host shadow tree.
+
+The `mode` option sets the encapsulation level. It must have any of two values:
+- `"open"` -- the shadow root is available as `elem.shadowRoot`.
+
+    Any code is able to access the shadow tree of `elem`.   
+- `"closed"` -- `elem.shadowRoot` is always `null`.
+
+    We can only access the shadow DOM by the reference returned by `attachShadow` (and probably hidden inside a class). Browser-native shadow trees, such as  `<input type="range">`, are closed. There's no way to access them.
+
+The [shadow root](https://dom.spec.whatwg.org/#shadowroot), returned by `attachShadow`, is like an element: we can use `innerHTML` or DOM methods, such as `append`, to populate it.
+
+The element with a shadow root is called a "shadow tree host", and is available as the shadow root `host` property:
+
+```js
+// assuming {mode: "open"}, otherwise elem.shadowRoot is null
+alert(elem.shadowRoot.host === elem); // true
+```
+
+## Encapsulation
+
+Shadow DOM is strongly delimited from the main document:
+
+1. Shadow DOM elements are not visible to `querySelector` from the light DOM. In particular,  Shadow DOM elements may have ids that conflict with those in the light DOM. They be unique only within the shadow tree.
+2. Shadow DOM has own stylesheets. Style rules from the outer DOM don't get applied.
+
+For example:
+
+```html run untrusted height=40
+<style>
+*!*
+  /* document style won't apply to the shadow tree inside #elem (1) */
+*/!*
+  p { color: red; }
+</style>
+
+<div id="elem"></div>
+
+<script>
+  elem.attachShadow({mode: 'open'});
+*!*
+    // shadow tree has its own style (2)
+*/!*
+  elem.shadowRoot.innerHTML = `
+    <style> p { font-weight: bold; } </style>
+    <p>Hello, John!</p>
+  `;
+
+*!*
+  // <p> is only visible from queries inside the shadow tree (3)
+*/!*
+  alert(document.querySelectorAll('p').length); // 0
+  alert(elem.shadowRoot.querySelectorAll('p').length); // 1
+</script>  
+```
+
+1. The style from the document does not affect the shadow tree.
+2. ...But the style from the inside works.
+3. To get elements in shadow tree, we must query from inside the tree.
+
+## References
+
+- DOM: <https://dom.spec.whatwg.org/#shadow-trees>
+- Compatibility: <https://caniuse.com/#feat=shadowdomv1>
+- Shadow DOM is mentioned in many other specifications, e.g. [DOM Parsing](https://w3c.github.io/DOM-Parsing/#the-innerhtml-mixin) specifies that shadow root has `innerHTML`.
+
+
+## Summary
+
+Shadow DOM is a way to create a component-local DOM.
+
+1. `shadowRoot = elem.attachShadow({mode: open|closed})` -- creates shadow DOM for `elem`. If `mode="open"`, then it's accessible as `elem.shadowRoot` property.
+2. We can populate `shadowRoot` using `innerHTML` or other DOM methods.
+
+Shadow DOM elements:
+- Have their own ids space,
+- Invisible to JavaScript selectors from the main document, such as `querySelector`,
+- Use styles only from the shadow tree, not from the main document.
+
+Shadow DOM, if exists, is rendered by the browser instead of so-called "light DOM" (regular children). In the chapter <info:slots-composition> we'll see how to compose them.
diff --git a/8-web-components/3-shadow-dom/shadow-dom-range.png b/8-web-components/3-shadow-dom/shadow-dom-range.png
new file mode 100644
index 000000000..126206107
Binary files /dev/null and b/8-web-components/3-shadow-dom/shadow-dom-range.png differ
diff --git a/8-web-components/3-shadow-dom/shadow-dom-range@2x.png b/8-web-components/3-shadow-dom/shadow-dom-range@2x.png
new file mode 100644
index 000000000..179d132ec
Binary files /dev/null and b/8-web-components/3-shadow-dom/shadow-dom-range@2x.png differ
diff --git a/8-web-components/3-shadow-dom/shadow-dom-say-hello.png b/8-web-components/3-shadow-dom/shadow-dom-say-hello.png
new file mode 100644
index 000000000..f99285e29
Binary files /dev/null and b/8-web-components/3-shadow-dom/shadow-dom-say-hello.png differ
diff --git a/8-web-components/3-shadow-dom/shadow-dom-say-hello@2x.png b/8-web-components/3-shadow-dom/shadow-dom-say-hello@2x.png
new file mode 100644
index 000000000..8f7bb2513
Binary files /dev/null and b/8-web-components/3-shadow-dom/shadow-dom-say-hello@2x.png differ
diff --git a/8-web-components/4-template-element/article.md b/8-web-components/4-template-element/article.md
new file mode 100644
index 000000000..4d9df9cb3
--- /dev/null
+++ b/8-web-components/4-template-element/article.md
@@ -0,0 +1,116 @@
+
+# Template element
+
+A built-in `<template>` element serves as a storage for markup. The browser ignores it contents, only checks for syntax validity, but we can access and use it in JavaScript, to create other elements.
+
+In theory, we could create any invisible element somewhere in HTML for markup storage purposes. What's special about `<template>`?
+
+First, its content can be any valid HTML, even if it normally requires a proper enclosing tag.
+
+For example, we can put there a table row `<tr>`:
+```html
+<template>
+  <tr>
+    <td>Contents</td>
+  </tr>
+</template>
+```
+
+Usually, if we try to put `<tr>` inside, say, a `<div>`, the browser detects the invalid DOM structure and "fixes" it, adds `<table>` around. That's not what we want. On the other hand, `<template>` keeps exactly what we place there.
+
+We can put styles and scripts into `<template>` as well:
+
+```html
+<template>
+  <style>
+    p { font-weight: bold; }
+  </style>
+  <script>
+    alert("Hello");
+  </script>
+</template>
+```
+
+The browser considers `<template>` content "out of the document", so the style is not applied, scripts are executed, `<video autoplay>` is not run, etc.
+
+The content becomes live (the script executes) when we insert it.
+
+## Inserting template
+
+The template content is available in its `content` property as a [DocumentFragment](info:modifying-document#document-fragment) -- a special type of DOM node.
+
+We can treat it as any other DOM node, except one special property: when we insert it somewhere, its children are inserted instead.
+
+For example:
+
+```html run
+<template id="tmpl">
+  <script>
+    alert("Hello");
+  </script>
+  <div class="message">Hello, world!</div>
+</template>
+
+<script>
+  let elem = document.createElement('div');
+
+*!*
+  // Clone the template content to reuse it multiple times
+  elem.append(tmpl.content.cloneNode(true));
+*/!*
+
+  document.body.append(elem);
+  // Now the script from <template> runs
+</script>
+```
+
+Let's rewrite a Shadow DOM example from the previous chapter using `<template>`:
+
+```html run untrusted autorun="no-epub" height=60
+<template id="tmpl">
+  <style> p { font-weight: bold; } </style>
+  <p id="message"></p>
+</template>
+
+<div id="elem">Click me</div>
+
+<script>
+  elem.onclick = function() {
+    elem.attachShadow({mode: 'open'});
+
+*!*
+    elem.shadowRoot.append(tmpl.content.cloneNode(true)); // (*)
+*/!*
+
+    elem.shadowRoot.getElementById('message').innerHTML = "Hello from the shadows!";
+  };
+</script>
+```
+
+In the line `(*)` when we clone and insert `tmpl.content`, its children (`<style>`, `<p>`) are inserted instead.
+
+They form the shadow DOM:
+
+```html
+<div id="elem">
+  #shadow-root
+    <style> p { font-weight: bold; } </style>
+    <p id="message"></p>
+</div>
+```
+
+## Summary
+
+To summarize:
+
+- `<template>` content can be any syntactically correct HTML.
+- `<template>` content is considered "out of the document", so it doesn't affect anything.
+- We can access `template.content` from JavaScript, clone it to reuse in a new component.
+
+The `<template>` tag is quite unique, because:
+
+- The browser checks the syntax inside it (as opposed to using a template string inside a script).
+- ...But still allows to use any top-level HTML tags, even those that don't make sense without proper wrappers (e.g. `<tr>`).
+- The content becomes interactive: scripts run, `<video autoplay>` plays etc, when inserted into the document.
+
+The `<template>` tag does not feature any sophisticated iteration mechanisms, data binding or variable substitutions, making it less powerful than frameworks. But we can build those on top of it.
diff --git a/8-web-components/5-slots-composition/article.md b/8-web-components/5-slots-composition/article.md
new file mode 100644
index 000000000..6ddc44245
--- /dev/null
+++ b/8-web-components/5-slots-composition/article.md
@@ -0,0 +1,432 @@
+# Shadow DOM slots, composition
+
+Many types of components, such as tabs, menus, image galleries, and so on, need the content to render.
+
+Just like built-in browser `<select>` expects `<option>` items, our `<custom-tabs>` may expect the actual tab content to be passed. And a `<custom-menu>` may expect menu items.
+
+The code that makes use of `<custom-menu>` can look like this:
+
+```html
+<custom-menu>
+  <title>Candy menu</title>
+  <item>Lollipop</item>
+  <item>Fruit Toast</item>
+  <item>Cup Cake</item>
+</custom-menu>
+```
+
+...Then our component should render it properly, as a nice menu with given title and items, handle menu events, etc.
+
+How to implement it?
+
+We could try to analyze the element content and dynamically copy-rearrange DOM nodes. That's possible, but if we're moving elements to shadow DOM, then CSS styles from the document do not apply in there, so the visual styling may be lost. Also that requires some coding.
+
+Luckily, we don't have to. Shadow DOM supports `<slot>` elements, that are automatically filled by the content from light DOM.
+
+## Named slots
+
+Let's see how slots work on a simple example.
+
+Here, `<user-card>` shadow DOM provides two slots, filled from light DOM:
+
+```html run autorun="no-epub" untrusted height=80
+<script>
+customElements.define('user-card', class extends HTMLElement {
+  connectedCallback() {
+    this.attachShadow({mode: 'open'});
+    this.shadowRoot.innerHTML = `
+      <div>Name:
+*!*
+        <slot name="username"></slot>
+*/!*
+      </div>
+      <div>Birthday:
+*!*
+        <slot name="birthday"></slot>
+*/!*
+      </div>
+    `;
+  }
+});
+</script>
+
+<user-card>
+  <span *!*slot="username"*/!*>John Smith</span>
+  <span *!*slot="birthday"*/!*>01.01.2001</span>
+</user-card>
+```
+
+In the shadow DOM, `<slot name="X">` defines an "insertion point", a place where elements with `slot="X"` are rendered.
+
+Then the browser performs "composition": it takes elements from the light DOM and renders them in corresponding slots of the shadow DOM. At the end, we have exactly what we want -- a generic component that can be filled with data.
+
+Here's the DOM structure after the script, not taking composition into account:
+
+```html
+<user-card>
+  #shadow-root
+    <div>Name:
+      <slot name="username"></slot>
+    </div>
+    <div>Birthday:
+      <slot name="birthday"></slot>
+    </div>
+  <span slot="username">John Smith</span>
+  <span slot="birthday">01.01.2001</span>
+</user-card>
+```
+
+There's nothing odd here. We created the shadow DOM, so here it is. Now the element has both light and shadow DOM.
+
+For rendering purposes, for each `<slot name="...">` in shadow DOM, the browser looks for `slot="..."` with the same name in the light DOM. These elements are rendered inside the slots:
+
+![](shadow-dom-user-card.png)
+
+The result is called "flattened" DOM:
+
+```html
+<user-card>
+  #shadow-root
+    <div>Name:
+      <slot name="username">
+        <!-- slotted element is inserted into the slot as a whole -->
+        <span slot="username">John Smith</span>
+      </slot>
+    </div>
+    <div>Birthday:
+      <slot name="birthday">
+        <span slot="birthday">01.01.2001</span>
+      </slot>
+    </div>
+</user-card>
+```
+
+...But the "flattened" DOM is only created for rendering and event-handling purposes. That's how things are shown. The nodes are actually not moved around!
+
+That can be easily checked if we run `querySelector`: nodes are still at their places.
+
+```js
+// light DOM <span> nodes are still at the same place, under `<user-card>`
+alert( document.querySelector('user-card span').length ); // 2
+```
+
+It may look bizarre, but for shadow DOM with slots we have one more "DOM level", the "flattened" DOM -- result of slot insertion. The browser renders it and uses for style inheritance, event propagation. But JavaScript still sees the document "as is", before flattening.
+
+````warn header="Only top-level children may have slot=\"...\" attribute"
+The `slot="..."` attribute is only valid for direct children of the shadow host (in our example, `<user-card>` element). For nested elements it's ignored.
+
+For example, the second `<span>` here is ignored (as it's not a top-level child of `<user-card>`):
+```html
+<user-card>
+  <span slot="username">John Smith</span>
+  <div>
+    <!-- bad slot, not top-level: -->
+    <span slot="birthday">01.01.2001</span>
+  </div>
+</user-card>
+```
+
+In practice, there's no sense in slotting a deeply nested element, so this limitation just ensures the correct DOM structure.
+````
+
+## Slot fallback content
+
+If we put something inside a `<slot>`, it becomes the fallback content. The browser shows it if there's no corresponding filler in light DOM.
+
+For example, in this piece of shadow DOM, `Anonymous` renders if there's no `slot="username"` in light DOM.
+
+```html
+<div>Name:
+  <slot name="username">Anonymous</slot>
+</div>
+```
+
+## Default slot
+
+The first `<slot>` in shadow DOM that doesn't have a name is a "default" slot. It gets all nodes from the light DOM that aren't slotted elsewhere.
+
+For example, let's add the default slot to our `<user-card>` that collects any unslotted information about the user:
+
+```html run autorun="no-epub" untrusted height=140
+<script>
+customElements.define('user-card', class extends HTMLElement {
+  connectedCallback() {
+    this.attachShadow({mode: 'open'});
+    this.shadowRoot.innerHTML = `
+    <div>Name:
+      <slot name="username"></slot>
+    </div>
+    <div>Birthday:
+      <slot name="birthday"></slot>
+    </div>
+    <fieldset>
+      <legend>Other information</legend>
+*!*
+      <slot></slot>
+*/!*
+    </fieldset>
+    `;
+  }
+});
+</script>
+
+<user-card>
+*!*
+  <div>I like to swim.</div>
+*/!*
+  <span slot="username">John Smith</span>
+  <span slot="birthday">01.01.2001</span>
+*!*
+  <div>...And play volleyball too!</div>
+*/!*
+</user-card>
+```
+
+All the unslotted light DOM content gets into the "Other information" fieldset.
+
+Elements are appended to a slot one after another, so both unslotted pieces of information are in the default slot together.
+
+The flattened DOM looks like this:
+
+```html
+<user-card>
+  #shadow-root
+    <div>Name:
+      <slot name="username">
+        <span slot="username">John Smith</span>
+      </slot>
+    </div>
+    <div>Birthday:
+      <slot name="birthday">
+        <span slot="birthday">01.01.2001</span>
+      </slot>
+    </div>
+    <fieldset>
+      <legend>About me</legend>
+*!*
+      <slot>
+        <div>Hello</div>
+        <div>I am John!</div>
+      </slot>
+*/!*
+    </fieldset>
+</user-card>
+```
+
+## Menu example
+
+Now let's back to `<custom-menu>`, mentioned at the beginning of the chapter.
+
+We can use slots to distribute elements.
+
+Here's the markup for `<custom-menu>`:
+
+```html
+<custom-menu>
+  <span slot="title">Candy menu</span>
+  <li slot="item">Lollipop</li>
+  <li slot="item">Fruit Toast</li>
+  <li slot="item">Cup Cake</li>
+</custom-menu>
+```
+
+The shadow DOM template with proper slots:
+
+```html
+<template id="tmpl">
+  <style> /* menu styles */ </style>
+  <div class="menu">
+    <slot name="title"></slot>
+    <ul><slot name="item"></slot></ul>
+  </div>
+</template>
+```
+
+1. `<span slot="title">` goes into `<slot name="title">`.
+2. There are many `<li slot="item">` in the template, but only one `<slot name="item">` in the template. That's perfectly normal. All elements with `slot="item"` get appended to `<slot name="item">` one after another, thus forming the list.
+
+The flattened DOM becomes:
+
+```html
+<custom-menu>
+  #shadow-root
+    <style> /* menu styles */ </style>
+    <div class="menu">
+      <slot name="title">
+        <span slot="title">Candy menu</span>
+      </slot>
+      <ul>
+        <slot name="item">
+          <li slot="item">Lollipop</li>
+          <li slot="item">Fruit Toast</li>
+          <li slot="item">Cup Cake</li>
+        </slot>
+      </ul>
+    </div>
+</custom-menu>
+```
+
+One might notice that, in a valid DOM, `<li>` must be a direct child of `<ul>`. But that's flattened DOM, it describes how the component is rendered, such thing happens naturally here.
+
+We just need to add a `click` handler to open/close the list, and the `<custom-menu>` is ready:
+
+```js
+customElements.define('custom-menu', class extends HTMLElement {
+  connectedCallback() {
+    this.attachShadow({mode: 'open'});
+
+    // tmpl is the shadow DOM template (above)
+    this.shadowRoot.append( tmpl.content.cloneNode(true) );
+
+    // we can't select light DOM nodes, so let's handle clicks on the slot
+    this.shadowRoot.querySelector('slot[name="title"]').onclick = () => {
+      // open/close the menu
+      this.shadowRoot.querySelector('.menu').classList.toggle('closed');
+    };
+  }
+});
+```
+
+Here's the full demo:
+
+[iframe src="menu" height=140 edit]
+
+Of course, we can add more functionality to it: events, methods and so on.
+
+## Monitoring slots
+
+What if the outer code wants to add/remove menu items dynamically?
+
+**The browser monitors slots and updates the rendering if slotted elements are added/removed.**
+
+Also, as light DOM nodes are not copied, but just rendered in slots, the changes inside them immediately become visible.
+
+So we don't have to do anything to update rendering. But if the component wants to know about slot changes, then `slotchange` event is available.
+
+For example, here the menu item is inserted dynamically after 1 second, and the title changes after 2 seconds:
+
+```html run untrusted height=80
+<custom-menu id="menu">
+  <span slot="title">Candy menu</span>
+</custom-menu>
+
+<script>
+customElements.define('custom-menu', class extends HTMLElement {
+  connectedCallback() {
+    this.attachShadow({mode: 'open'});
+    this.shadowRoot.innerHTML = `<div class="menu">
+      <slot name="title"></slot>
+      <ul><slot name="item"></slot></ul>
+    </div>`;
+
+    // shadowRoot can't have event handlers, so using the first child
+    this.shadowRoot.firstElementChild.addEventListener('slotchange',
+      e => alert("slotchange: " + e.target.name)
+    );
+  }
+});
+
+setTimeout(() => {
+  menu.insertAdjacentHTML('beforeEnd', '<li slot="item">Lollipop</li>')
+}, 1000);
+
+setTimeout(() => {
+  menu.querySelector('[slot="title"]').innerHTML = "New menu";
+}, 2000);
+</script>
+```
+
+The menu rendering updates each time without our intervention.
+
+There are two `slotchange` events here:
+
+1. At initialization:
+
+    `slotchange: title` triggers immediately, as the `slot="title"` from the light DOM gets into the corresponding slot.
+2. After 1 second:
+
+    `slotchange: item` triggers, when a new `<li slot="item">` is added.
+
+Please note: there's no `slotchange` event after 2 seconds, when the content of `slot="title"` is modified. That's because there's no slot change. We modify the content inside the slotted element, that's another thing.
+
+If we'd like to track internal modifications of light DOM from JavaScript, that's also possible using a more generic mechanism: [MutationObserver](info:mutation-observer).
+
+## Slot API
+
+Finally, let's mention the slot-related JavaScript methods.
+
+As we've seen before, JavaScript looks at the "real" DOM, without flattening. But, if the shadow tree has `{mode: 'open'}`, then we can figure out which elements assigned to a slot and, vise-versa, the slot by the element inside it:
+
+- `node.assignedSlot` -- returns the `<slot>` element that the `node` is assigned to.
+- `slot.assignedNodes({flatten: true/false})` -- DOM nodes, assigned to the slot. The `flatten` option is `false` by default. If explicitly set to `true`, then it looks more deeply into the flattened DOM, returning nested slots in case of nested components and the fallback content if no node assigned.
+- `slot.assignedElements({flatten: true/false})` -- DOM elements, assigned to the slot (same as above, but only element nodes).
+
+These methods are useful when we need not just show the slotted content, but also track it in JavaScript.
+
+For example, if `<custom-menu>` component wants to know, what it shows, then it could track `slotchange` and get the items from `slot.assignedElements`:
+
+```html run untrusted height=120
+<custom-menu id="menu">
+  <span slot="title">Candy menu</span>
+  <li slot="item">Lollipop</li>
+  <li slot="item">Fruit Toast</li>
+</custom-menu>
+
+<script>
+customElements.define('custom-menu', class extends HTMLElement {
+  items = []
+
+  connectedCallback() {
+    this.attachShadow({mode: 'open'});
+    this.shadowRoot.innerHTML = `<div class="menu">
+      <slot name="title"></slot>
+      <ul><slot name="item"></slot></ul>
+    </div>`;
+
+    // slottable is added/removed/replaced
+*!*
+    this.shadowRoot.firstElementChild.addEventListener('slotchange', e => {
+      let slot = e.target;
+      if (slot.name == 'item') {
+        this.items = slot.assignedElements().map(elem => elem.textContent);
+        alert("Items: " + this.items);
+      }
+    });
+*/!*
+  }
+});
+
+// items update after 1 second
+setTimeout(() => {
+  menu.insertAdjacentHTML('beforeEnd', '<li slot="item">Cup Cake</li>')
+}, 1000);
+</script>
+```
+
+
+## Summary
+
+Slots allow to show light DOM children in shadow DOM.
+
+There are two kinds of slots:
+
+- Named slots: `<slot name="X">...</slot>` -- gets light children with `slot="X"`.
+- Default slot: the first `<slot>` without a name (subsequent unnamed slots are ignored) -- gets unslotted light children.
+- If there are many elements for the same slot -- they are appended one after another.
+- The content of `<slot>` element is used as a fallback. It's shown if there are no light children for the slot.
+
+The process of rendering slotted elements inside their slots is called "composition". The result is called a "flattened DOM".
+
+Composition does not really move nodes, from JavaScript point of view the DOM is still same.
+
+JavaScript can access slots using methods:
+- `slot.assignedNodes/Elements()` -- returns nodes/elements inside the `slot`.
+- `node.assignedSlot` -- the reverse meethod, returns slot by a node.
+
+If we'd like to know what we're showing, we can track slot contents using:
+- `slotchange` event -- triggers the first time a slot is filled, and on any add/remove/replace operation of the slotted element, but not its children. The slot is `event.target`.
+- [MutationObserver](info:mutation-observer) to go deeper into slot content, watch changes inside it.
+
+Now, as we have elements from light DOM in the shadow DOM, let's see how to style them properly. The basic rule is that shadow elements are styled inside, and light elements -- outside, but there are notable exceptions.
+
+We'll see the details in the next chapter.
diff --git a/8-web-components/5-slots-composition/menu.view/index.html b/8-web-components/5-slots-composition/menu.view/index.html
new file mode 100644
index 000000000..86b31d860
--- /dev/null
+++ b/8-web-components/5-slots-composition/menu.view/index.html
@@ -0,0 +1,54 @@
+<!doctype html>
+<template id="tmpl">
+  <style>
+  ul {
+    margin: 0;
+    list-style: none;
+    padding-left: 20px;
+  }
+
+  ::slotted([slot="title"]) {
+    font-size: 18px;
+    font-weight: bold;
+    cursor: pointer;
+  }
+
+  ::slotted([slot="title"])::before {
+    content: '📂';
+    font-size: 14px;
+  }
+
+  .closed ::slotted([slot="title"])::before {
+    content: '📁';
+  }
+
+  .closed ul {
+    display: none;
+  }
+  </style>
+
+  <div class="menu">
+    <slot name="title"></slot>
+    <ul><slot name="item"></slot></ul>
+  </div>
+</template>
+
+<script>
+customElements.define('custom-menu', class extends HTMLElement {
+  connectedCallback() {
+    this.attachShadow({mode: 'open'});
+    this.shadowRoot.append( tmpl.content.cloneNode(true) );
+
+    this.shadowRoot.querySelector('slot[name="title"]').onclick = () => {
+      this.shadowRoot.querySelector('.menu').classList.toggle('closed');
+    };
+  }
+});
+</script>
+
+<custom-menu>
+  <span slot="title">Candy menu</span>
+  <li slot="item">Lollipop</li>
+  <li slot="item">Fruit Toast</li>
+  <li slot="item">Cup Cake</li>
+</custom-menu>
diff --git a/8-web-components/5-slots-composition/shadow-dom-user-card.png b/8-web-components/5-slots-composition/shadow-dom-user-card.png
new file mode 100644
index 000000000..8b9983b3c
Binary files /dev/null and b/8-web-components/5-slots-composition/shadow-dom-user-card.png differ
diff --git a/8-web-components/5-slots-composition/shadow-dom-user-card@2x.png b/8-web-components/5-slots-composition/shadow-dom-user-card@2x.png
new file mode 100644
index 000000000..83e12d44a
Binary files /dev/null and b/8-web-components/5-slots-composition/shadow-dom-user-card@2x.png differ
diff --git a/8-web-components/6-shadow-dom-style/article.md b/8-web-components/6-shadow-dom-style/article.md
new file mode 100644
index 000000000..66e5cc13d
--- /dev/null
+++ b/8-web-components/6-shadow-dom-style/article.md
@@ -0,0 +1,334 @@
+# Shadow DOM styling
+
+Shadow DOM may include both `<style>` and `<link rel="stylesheet" href="…">` tags. In the latter case, stylesheets are HTTP-cached, so they are not redownloaded. There's no overhead in @importing or linking same styles for many components.
+
+As a general rule, local styles work only inside the shadow tree, and document styles work outside of it. But there are few exceptions.
+
+## :host
+
+The `:host` selector allows to select the shadow host (the element containing the shadow tree).
+
+For instance, we're making `<custom-dialog>` element that should be centered. For that we need to style the `<custom-dialog>` element itself.
+
+That's exactly what `:host` does:
+
+```html run autorun="no-epub" untrusted height=80
+<template id="tmpl">
+  <style>
+    /* the style will be applied from inside to the custom-dialog element */
+    :host {
+      position: fixed;
+      left: 50%;
+      top: 50%;
+      transform: translate(-50%, -50%);
+      display: inline-block;
+      border: 1px solid red;
+      padding: 10px;
+    }
+  </style>
+  <slot></slot>
+</template>
+
+<script>
+customElements.define('custom-dialog', class extends HTMLElement {
+  connectedCallback() {
+    this.attachShadow({mode: 'open'}).append(tmpl.content.cloneNode(true));
+  }
+});
+</script>
+
+<custom-dialog>
+  Hello!
+</custom-dialog>
+```
+
+## Cascading
+
+The shadow host (`<custom-dialog>` itself) resides in the light DOM, so it's affected by the main CSS cascade.
+
+If there's a property styled both in `:host` locally, and in the document, then the document style takes precedence.
+
+For instance, if in the document we had:
+```html
+<style>
+custom-dialog {
+  padding: 0;
+}
+</style>
+```
+...Then the `<custom-dialog>` would be without padding.
+
+It's very convenient, as we can setup "default" styles in the component `:host` rule, and then easily override them in the document.
+
+The exception is when a local property is labelled `!important`, for such properties, local styles take precedence.
+
+
+## :host(selector)
+
+Same as `:host`, but applied only if the shadow host matches the `selector`.
+
+For example, we'd like to center the `<custom-dialog>` only if it has `centered` attribute:
+
+```html run autorun="no-epub" untrusted height=80
+<template id="tmpl">
+  <style>
+*!*
+    :host([centered]) {
+*/!*
+      position: fixed;
+      left: 50%;
+      top: 50%;
+      transform: translate(-50%, -50%);
+    }
+
+    :host {
+      display: inline-block;
+      border: 1px solid red;
+      padding: 10px;
+    }
+  </style>
+  <slot></slot>
+</template>
+
+<script>
+customElements.define('custom-dialog', class extends HTMLElement {
+  connectedCallback() {
+    this.attachShadow({mode: 'open'}).append(tmpl.content.cloneNode(true));
+  }
+});
+</script>
+
+
+<custom-dialog centered>
+  Centered!
+</custom-dialog>
+
+<custom-dialog>
+  Not centered.
+</custom-dialog>
+```
+
+Now the additional centering styles are only applied to the first dialog `<custom-dialog centered>`.
+
+## :host-context(selector)
+
+Same as `:host`, but applied only if the shadow host or any of its ancestors in the outer document matches the `selector`.
+
+E.g. `:host-context(.dark-theme)` matches only if there's `dark-theme` class on `<custom-dialog>` on above it:
+
+```html
+<body class="dark-theme">
+  <!--
+    :host-context(.dark-theme) applies to custom-dialogs inside .dark-theme
+  -->
+  <custom-dialog>...</custom-dialog>
+</body>
+```
+
+To summarize, we can use `:host`-family of selectors to style the main element of the component, depending on the context. These styles (unless `!important`) can be overridden by the document.
+
+## Styling slotted content
+
+Now let's consider the situation with slots.
+
+Slotted elements come from light DOM, so they use document styles. Local styles do not affect slotted content.
+
+In the example below, slotted `<span>` is bold, as per document style, but does not take `background` from the local style:
+```html run autorun="no-epub" untrusted height=80
+<style>
+*!*
+  span { font-weight: bold }
+*/!*
+</style>
+
+<user-card>
+  <div slot="username">*!*<span>John Smith</span>*/!*</div>
+</user-card>
+
+<script>
+customElements.define('user-card', class extends HTMLElement {
+  connectedCallback() {
+    this.attachShadow({mode: 'open'});
+    this.shadowRoot.innerHTML = `
+      <style>
+*!*
+      span { background: red; }
+*/!*
+      </style>
+      Name: <slot name="username"></slot>
+    `;
+  }
+});
+</script>
+```
+
+The result is bold, but not red.
+
+If we'd like to style slotted elements in our component, there are two choices.
+
+First, we can style the `<slot>` itself and rely on CSS inheritance:
+
+```html run autorun="no-epub" untrusted height=80
+<user-card>
+  <div slot="username">*!*<span>John Smith</span>*/!*</div>
+</user-card>
+
+<script>
+customElements.define('user-card', class extends HTMLElement {
+  connectedCallback() {
+    this.attachShadow({mode: 'open'});
+    this.shadowRoot.innerHTML = `
+      <style>
+*!*
+      slot[name="username"] { font-weight: bold; }
+*/!*
+      </style>
+      Name: <slot name="username"></slot>
+    `;
+  }
+});
+</script>
+```
+
+Here `<p>John Smith</p>` becomes bold, because CSS inheritance is in effect between the `<slot>` and its contents. But not all CSS properties are inherited.
+
+Another option is to use `::slotted(selector)` pseudo-class. It matches elements based on two conditions:
+
+1. The element from the light DOM that is inserted into a `<slot>`. Then slot name doesn't matter. Just any slotted element, but only the element itself, not its children.
+2. The element matches the `selector`.
+
+In our example, `::slotted(div)` selects exactly `<div slot="username">`, but not its children:
+
+```html run autorun="no-epub" untrusted height=80
+<user-card>
+  <div slot="username">
+    <div>John Smith</div>
+  </div>
+</user-card>
+
+<script>
+customElements.define('user-card', class extends HTMLElement {
+  connectedCallback() {
+    this.attachShadow({mode: 'open'});
+    this.shadowRoot.innerHTML = `
+      <style>
+*!*
+      ::slotted(div) { border: 1px solid red; }
+*/!*
+      </style>
+      Name: <slot name="username"></slot>
+    `;
+  }
+});
+</script>
+```
+
+Please note, `::slotted` selector can't descend any further into the slot. These selectors are invalid:
+
+```css
+::slotted(div span) {
+  /* our slotted <div> does not match this */
+}
+
+::slotted(div) p {
+  /* can't go inside light DOM */
+}
+```
+
+Also, `::slotted` can only be used in CSS. We can't use it in `querySelector`.
+
+## CSS hooks with custom properties
+
+How do we style a component in-depth from the main document?
+
+Naturally, document styles apply to `<custom-dialog>` element or `<user-card>`, etc. But how can we affect its internals? For instance, in `<user-card>` we'd like to allow the outer document change how user fields look.
+
+Just as we expose methods to interact with our component, we can expose CSS variables (custom CSS properties) to style it.
+
+**Custom CSS properties exist on all levels, both in light and shadow.**
+
+For example, in shadow DOM we can use `--user-card-field-color` CSS variable to style fields:
+
+```html
+<style>
+  .field {
+    color: var(--user-card-field-color, black);
+    /* if --user-card-field-color is not defined, use black */
+  }
+</style>
+<div class="field">Name: <slot name="username"></slot></div>
+<div class="field">Birthday: <slot name="birthday"></slot></div>
+</style>
+```
+
+Then, we can declare this property in the outer document for `<user-card>`:
+
+```css
+user-card {
+  --user-card-field-color: green;
+}
+```
+
+Custom CSS properties pierce through shadow DOM, they are visible everywhere, so the inner `.field` rule will make use of it.
+
+Here's the full example:
+
+```html run autorun="no-epub" untrusted height=80
+<style>
+*!*
+  user-card {
+    --user-card-field-color: green;
+  }
+*/!*
+</style>
+
+<template id="tmpl">
+  <style>
+*!*
+    .field {
+      color: var(--user-card-field-color, black);
+    }
+*/!*
+  </style>
+  <div class="field">Name: <slot name="username"></slot></div>
+  <div class="field">Birthday: <slot name="birthday"></slot></div>
+</template>
+
+<script>
+customElements.define('user-card', class extends HTMLElement {
+  connectedCallback() {
+    this.attachShadow({mode: 'open'});
+    this.shadowRoot.append(document.getElementById('tmpl').content.cloneNode(true));
+  }
+});
+</script>
+
+<user-card>
+  <span slot="username">John Smith</span>
+  <span slot="birthday">01.01.2001</span>
+</user-card>
+```
+
+
+
+## Summary
+
+Shadow DOM can include styles, such as `<style>` or `<link rel="stylesheet">`.
+
+Local styles can affect:
+- shadow tree,
+- shadow host with `:host`-family pseudoclasses,
+- slotted elements (coming from light DOM), `::slotted(selector)` allows to select  slotted elements themselves, but not their children.
+
+Document styles can affect:
+- shadow host (as it's in the outer document)
+- slotted elements and their contents (as it's physically in the outer document)
+
+When CSS properties conflict, normally document styles have precedence, unless the property is labelled as `!important`. Then local styles have precedence.
+
+CSS custom properties pierce through shadow DOM. They are used as "hooks" to style the component:
+
+1. The component uses a custom CSS property to style key elements, such as `var(--component-name-title, <default value>)`.
+2. Component author publishes these properties for developers, they are same important as other public component methods.
+3. When a developer wants to style a title, they assign `--component-name-title` CSS property for the shadow host or above.
+4. Profit!
diff --git a/8-web-components/7-shadow-dom-events/article.md b/8-web-components/7-shadow-dom-events/article.md
new file mode 100644
index 000000000..14e310a55
--- /dev/null
+++ b/8-web-components/7-shadow-dom-events/article.md
@@ -0,0 +1,192 @@
+# Shadow DOM and events
+
+The idea behind shadow tree is to encapsulate internal implementation details of a component.
+
+Let's say, a click event happens inside a shadow DOM of `<user-card>` component. But scripts in the main document have no idea about the shadow DOM internals, especially if the component comes from a 3rd-party library or so.  
+
+So, to keep things simple, the browser *retargets* the event.
+
+**Events that happen in shadow DOM have the host element as the target, when caught outside of the component.**
+
+Here's a simple example:
+
+```html run autorun="no-epub" untrusted height=60
+<user-card></user-card>
+
+<script>
+customElements.define('user-card', class extends HTMLElement {
+  connectedCallback() {
+    this.attachShadow({mode: 'open'});
+    this.shadowRoot.innerHTML = `<p>
+      <button>Click me</button>
+    </p>`;
+    this.shadowRoot.firstElementChild.onclick =
+      e => alert("Inner target: " + e.target.tagName);
+  }
+});
+
+document.onclick =
+  e => alert("Outer target: " + e.target.tagName);
+</script>
+```
+
+If you click on the button, the messages are:
+
+1. Inner target: `BUTTON` -- internal event handler gets the correct target, the element inside shadow DOM.
+2. Outer target: `USER-CARD` -- document event handler gets shadow host as the target.
+
+Event retargeting is a great thing to have, because the outer document doesn't have no know  about component internals. From its point of view, the event happened on `<user-card>`.
+
+**Retargeting does not occur if the event occurs on a slotted element, that physically lives in the light DOM.**
+
+For example, if a user clicks on `<span slot="username">` in the example below, the event target is exactly this element, for both shadow and light handlers:
+
+```html run autorun="no-epub" untrusted height=60
+<user-card id="userCard">
+*!*
+  <span slot="username">John Smith</span>
+*/!*
+</user-card>
+
+<script>
+customElements.define('user-card', class extends HTMLElement {
+  connectedCallback() {
+    this.attachShadow({mode: 'open'});
+    this.shadowRoot.innerHTML = `<div>
+      <b>Name:</b> <slot name="username"></slot>
+    </div>`;
+
+    this.shadowRoot.firstElementChild.onclick =
+      e => alert("Inner target: " + e.target.tagName);
+  }
+});
+
+userCard.onclick = e => alert(`Outer target: ${e.target.tagName}`);
+</script>
+```
+
+If a click happens on `"John Smith"`, for both inner and outer handlers the target is `<span slot="username">`. That's an element from the light DOM, so no retargeting.
+
+On the other hand, if the click occurs on an element originating from shadow DOM, e.g. on `<b>Name</b>`, then, as it bubbles out of the shadow DOM, its `event.target` is reset to `<user-card>`.
+
+## Bubbling, event.composedPath()
+
+For purposes of event bubbling, flattened DOM is used.
+
+So, if we have a slotted element, and an event occurs somewhere inside it, then it bubbles up to the `<slot>` and upwards.
+
+The full path to the original event target, with all the shadow root elements, can be obtained using `event.composedPath()`. As we can see from the name of the method, that path is taken after the composition.
+
+In the example above, the flattened DOM is:
+
+```html
+<user-card id="userCard">
+  #shadow-root
+    <div>
+      <b>Name:</b>
+      <slot name="username">
+        <span slot="username">John Smith</span>
+      </slot>
+    </div>
+</user-card>
+```
+
+
+So, for a click on `<span slot="username">`, a call to `event.composedPath()` returns an array: [`span`, `slot`, `div`, `shadow-root`, `user-card`, `body`, `html`, `document`, `window`]. That's exactly the parent chain from the target element in the flattened DOM, after the composition.
+
+```warn header="Shadow tree details are only provided for `{mode:'open'}` trees"
+If the shadow tree was created with `{mode: 'closed'}`, then the composed path starts from the host: `user-card` and upwards.
+
+That's the similar principle as for other methods that work with shadow DOM. Internals of closed trees are completely hidden.
+```
+
+
+## event.composed
+
+Most events successfully bubble through a shadow DOM boundary. There are few events that do not.
+
+This is governed by the `composed` event object property. If it's `true`, then the event does cross the boundary. Otherwise, it only can be caught from inside the shadow DOM.
+
+If you take a look at [UI Events specification](https://www.w3.org/TR/uievents), most events have `composed: true`:
+
+- `blur`, `focus`, `focusin`, `focusout`,
+- `click`, `dblclick`,
+- `mousedown`, `mouseup` `mousemove`, `mouseout`, `mouseover`,
+- `wheel`,
+- `beforeinput`, `input`, `keydown`, `keyup`.
+
+All touch events and pointer events also have `composed: true`.
+
+There are some events that have `composed: false` though:
+
+- `mouseenter`, `mouseleave` (they also do not bubble),
+- `load`, `unload`, `abort`, `error`,
+- `select`,
+- `slotchange`.
+
+These events can be caught only on elements within the same DOM, where the event target resides.
+
+## Custom events
+
+When we dispatch custom events, we need to set both `bubbles` and `composed` properties to `true` for it to bubble up and out of the component.
+
+For example, here we create `div#inner` in the shadow DOM of `div#outer` and trigger two events on it. Only the one with `composed: true` makes it outside to the document:
+
+```html run untrusted height=0
+<div id="outer"></div>
+
+<script>
+outer.attachShadow({mode: 'open'});
+
+let inner = document.createElement('div');
+outer.shadowRoot.append(inner);
+
+/*
+div(id=outer)
+  #shadow-dom
+    div(id=inner)
+*/
+
+document.addEventListener('test', event => alert(event.detail));
+
+inner.dispatchEvent(new CustomEvent('test', {
+  bubbles: true,
+*!*
+  composed: true,
+*/!*
+  detail: "composed"
+}));
+
+inner.dispatchEvent(new CustomEvent('test', {
+  bubbles: true,
+*!*
+  composed: false,
+*/!*
+  detail: "not composed"
+}));
+</script>
+```
+
+## Summary
+
+Events only cross shadow DOM boundaries if their `composed` flag is set to `true`.
+
+Built-in events mostly have `composed: true`, as described in the relevant specifications:
+
+- UI Events <https://www.w3.org/TR/uievents>.
+- Touch Events <https://w3c.github.io/touch-events>.
+- Pointer Events <https://www.w3.org/TR/pointerevents>.
+- ...And so on.
+
+Some built-in events that have `composed: false`:
+
+- `mouseenter`, `mouseleave` (also do not bubble),
+- `load`, `unload`, `abort`, `error`,
+- `select`,
+- `slotchange`.
+
+These events can be caught only on elements within the same DOM.
+
+If we dispatch a `CustomEvent`, then we should explicitly set `composed: true`.
+
+Please note that in case of nested components, composed events bubble through all shadow DOM boundaries. So, if an event is intended only for the immediate enclosing component, we can also dispatch it on the shadow host. Then it's out of the shadow DOM already.
diff --git a/8-web-components/index.md b/8-web-components/index.md
new file mode 100644
index 000000000..f572ed3d4
--- /dev/null
+++ b/8-web-components/index.md
@@ -0,0 +1,3 @@
+# Web components
+
+Web components is a set of standards to make self-contained components: custom HTML-elements with their own properties and methods, encapsulated DOM and styles.
diff --git a/5-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
similarity index 73%
rename from 5-regular-expressions/01-regexp-introduction/article.md
rename to 9-regular-expressions/01-regexp-introduction/article.md
index 5b6c9473b..59775d3c0 100644
--- a/5-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -53,7 +53,7 @@ alert( str.search(substr) ); // 2
 
 So searching for `pattern:/love/` is the same as searching for `"love"`.
 
-But that's only for now. Soon we'll create more complex regular expressions with much searching more power.
+But that's only for now. Soon we'll create more complex regular expressions with much more searching power.
 
 ```smart header="Colors"
 From here on the color scheme is:
@@ -65,18 +65,18 @@ From here on the color scheme is:
 
 
 ````smart header="When to use `new RegExp`?"
-Normally we use the short syntax `/.../`. But it does not allow any variables insertions, so we must know the exact regexp at the time of writing the code.
+Normally we use the short syntax `/.../`. But it does not support variable insertions `${...}`.
 
-From the other hand, `new RegExp` allows to construct a pattern dynamically from a string.
+On the other hand, `new RegExp` allows to construct a pattern dynamically from a string, so it's more flexible.
 
-So we can figure out what we need to search and create `new RegExp` from it:
+Here's an example of a dynamically generated regexp:
 
 ```js run
-let search = prompt("What you want to search?", "love");
-let regexp = new RegExp(search);
+let tag = prompt("Which tag you want to search?", "h2");
+let regexp = new RegExp(`<${tag}>`);
 
-// find whatever the user wants
-alert( "I love JavaScript".search(regexp));
+// finds <h2> by default
+alert( "<h1> <h2> <h3>".search(regexp));
 ```
 ````
 
@@ -94,36 +94,34 @@ There are only 5 of them in JavaScript:
 : With this flag the search looks for all matches, without it -- only the first one (we'll see uses in the next chapter).
 
 `m`
-: Multiline mode (covered in the chapter <info:regexp-multiline>).
+: Multiline mode (covered in the chapter <info:regexp-multiline-mode>).
+
+`s`
+: "Dotall" mode, allows `.` to match newlines (covered in the chapter <info:regexp-character-classes>).
 
 `u`
 : Enables full unicode support. The flag enables correct processing of surrogate pairs. More about that in the chapter <info:regexp-unicode>.
 
 `y`
-: Sticky mode (covered in the [next chapter](info:regexp-methods#y-flag))
-
-
-## The "i" flag
+: Sticky mode (covered in the chapter <info:regexp-sticky>)
 
-The simplest flag is `i`.
+We'll cover all these flags further in the tutorial.
 
-An example with it:
+For now, the simplest flag is `i`, here's an example:
 
 ```js run
 let str = "I love JavaScript!";
 
-alert( str.search(/LOVE/) ); // -1 (not found)
-alert( str.search(/LOVE/i) ); // 2
-```
+alert( str.search(/LOVE/i) ); // 2 (found lowercased)
 
-1. The first search returns `-1` (not found), because the search is case-sensitive by default.
-2. With the flag `pattern:/LOVE/i` the search found `match:love` at position 2.
+alert( str.search(/LOVE/) ); // -1 (nothing found without 'i' flag)
+```
 
 So the `i` flag already makes regular expressions more powerful than a simple substring search. But there's so much more. We'll cover other flags and features in the next chapters.
 
 
 ## Summary
 
-- A regular expression consists of a pattern and optional flags: `g`, `i`, `m`, `u`, `y`.
+- A regular expression consists of a pattern and optional flags: `g`, `i`, `m`, `u`, `s`, `y`.
 - Without flags and special symbols that we'll study later, the search by a regexp is the same as a  substring search.
-- The method `str.search(regexp)` returns the index where the match is found or `-1` if there's no match.
+- The method `str.search(regexp)` returns the index where the match is found or `-1` if there's no match. In the next chapter we'll see other methods.
diff --git a/9-regular-expressions/02-regexp-methods/article.md b/9-regular-expressions/02-regexp-methods/article.md
new file mode 100644
index 000000000..fa8cbf7b7
--- /dev/null
+++ b/9-regular-expressions/02-regexp-methods/article.md
@@ -0,0 +1,458 @@
+# Methods of RegExp and String
+
+There are two sets of methods to deal with regular expressions.
+
+1. First, regular expressions are objects of the built-in [RegExp](mdn:js/RegExp) class, it provides many methods.
+2. Besides that, there are methods in regular strings can work with regexps.
+
+
+## Recipes
+
+Which method to use depends on what we'd like to do.
+
+Methods become much easier to understand if we separate them by their use in real-life tasks:
+
+**To search for all matches:**
+
+Use regexp `g` flag and:
+- Get a flat array of matches -- `str.match(reg)`
+- Get an array or matches with details -- `str.matchAll(reg)`.
+
+**To search for the first match only:**
+- Get the full first match -- `str.match(reg)` (without `g` flag).
+- Get the string position of the first match -- `str.search(reg)`.
+- Check if there's a match -- `regexp.test(str)`.
+- Find the match from the given position -- `regexp.exec(str)` (set `regexp.lastIndex` to position).
+
+**To replace all matches:**
+- Replace with another string or a function result -- `str.replace(reg, str|func)`
+
+**To split the string by a separator:**
+- `str.split(str|reg)`
+
+Now you get the details about every method in this chapter... But if you're reading for the first time, and want to know more about regexps - go ahead!
+
+You may want to skip methods for now, move on to the next chapter, and then return here if something about a method is unclear.
+
+## str.search(reg)
+
+We've seen this method already. It returns the position of the first match or `-1` if none found:
+
+```js run
+let str = "A drop of ink may make a million think";
+
+alert( str.search( *!*/a/i*/!* ) ); // 0 (the first position)
+```
+
+**The important limitation: `search` only finds  the first match.**
+
+We can't find next positions using `search`, there's just no syntax for that. But there are other methods that can.
+
+## str.match(reg), no "g" flag
+
+The behavior of `str.match` varies depending on whether `reg` has `g` flag or not.
+
+First, if there's no `g` flag, then `str.match(reg)` looks for the first match only.
+
+The result is an array with that match and additional properties:
+
+- `index` -- the position of the match inside the string,
+- `input` -- the subject string.
+
+For instance:
+
+```js run
+let str = "Fame is the thirst of youth";
+
+let result = str.match( *!*/fame/i*/!* );
+
+alert( result[0] );    // Fame (the match)
+alert( result.index ); // 0 (at the zero position)
+alert( result.input ); // "Fame is the thirst of youth" (the string)
+```
+
+A match result may have more than one element.
+
+**If a part of the pattern is delimited by parentheses `(...)`, then it becomes a separate element in the array.**
+
+If parentheses have a name, designated by `(?<name>...)` at their start, then `result.groups[name]` has the content. We'll see that later in the chapter [about groups](info:regexp-groups).
+
+For instance:
+
+```js run
+let str = "JavaScript is a programming language";
+
+let result = str.match( *!*/JAVA(SCRIPT)/i*/!* );
+
+alert( result[0] ); // JavaScript (the whole match)
+alert( result[1] ); // script (the part of the match that corresponds to the parentheses)
+alert( result.index ); // 0
+alert( result.input ); // JavaScript is a programming language
+```
+
+Due to the `i` flag the search is case-insensitive, so it finds `match:JavaScript`. The part of the match that corresponds to `pattern:SCRIPT` becomes a separate array item.
+
+So, this method is used to find one full match with all details.
+
+
+## str.match(reg) with "g" flag
+
+When there's a `"g"` flag, then `str.match` returns an array of all matches. There are no additional properties in that array, and parentheses do not create any elements.
+
+For instance:
+
+```js run
+let str = "HO-Ho-ho!";
+
+let result = str.match( *!*/ho/ig*/!* );
+
+alert( result ); // HO, Ho, ho (array of 3 matches, case-insensitive)
+```
+
+Parentheses do not change anything, here we go:
+
+```js run
+let str = "HO-Ho-ho!";
+
+let result = str.match( *!*/h(o)/ig*/!* );
+
+alert( result ); // HO, Ho, ho
+```
+
+**So, with `g` flag `str.match` returns a simple array of all matches, without details.**
+
+If we want to get information about match positions and contents of parentheses then we should use `matchAll`  method that we'll cover below.
+
+````warn header="If there are no matches, `str.match` returns `null`"
+Please note, that's important. If there are no matches, the result is not an empty array, but `null`.
+
+Keep that in mind to evade pitfalls like this:
+
+```js run
+let str = "Hey-hey-hey!";
+
+alert( str.match(/Z/g).length ); // Error: Cannot read property 'length' of null
+```
+
+Here `str.match(/Z/g)` is `null`, it has no `length` property.
+````
+
+## str.matchAll(regexp)
+
+The method `str.matchAll(regexp)` is used to find all matches with all details.
+
+For instance:
+
+```js run
+let str = "Javascript or JavaScript? Should we uppercase 'S'?";
+
+let result = str.matchAll( *!*/java(script)/ig*/!* );
+
+let [match1, match2] = result;
+
+alert( match1[0] ); // Javascript (the whole match)
+alert( match1[1] ); // script (the part of the match that corresponds to the parentheses)
+alert( match1.index ); // 0
+alert( match1.input ); // = str (the whole original string)
+
+alert( match2[0] ); // JavaScript (the whole match)
+alert( match2[1] ); // Script (the part of the match that corresponds to the parentheses)
+alert( match2.index ); // 14
+alert( match2.input ); // = str (the whole original string)
+```
+
+````warn header="`matchAll` returns an iterable, not array"
+For instance, if we try to get the first match by index, it won't work:
+
+```js run
+let str = "Javascript or JavaScript??";
+
+let result = str.matchAll( /javascript/ig );
+
+*!*
+alert(result[0]); // undefined (?! there must be a match)
+*/!*
+```
+
+The reason is that the iterator is not an array. We need to run `Array.from(result)` on it, or use `for..of` loop to get matches.
+
+In practice, if we need all matches, then `for..of` works, so it's not a problem.
+
+And, to get only few matches, we can use destructuring:
+
+```js run
+let str = "Javascript or JavaScript??";
+
+*!*
+let [firstMatch] = str.matchAll( /javascript/ig );
+*/!*
+
+alert(firstMatch); // Javascript
+```
+````
+
+```warn header="`matchAll` is supernew, may need a polyfill"
+The method may not work in old browsers. A polyfill might be needed (this site uses core-js).
+
+Or you could make a loop with `regexp.exec`, explained below.
+```
+
+## str.split(regexp|substr, limit)
+
+Splits the string using the regexp (or a substring) as a delimiter.
+
+We already used `split` with strings, like this:
+
+```js run
+alert('12-34-56'.split('-')) // array of [12, 34, 56]
+```
+
+But we can split by a regular expression, the same way:
+
+```js run
+alert('12-34-56'.split(/-/)) // array of [12, 34, 56]
+```
+
+## str.replace(str|reg, str|func)
+
+That's actually a great method, one of most useful ones. The swiss army knife for searching and replacing.
+
+The simplest use -- searching and replacing a substring, like this:
+
+```js run
+// replace a dash by a colon
+alert('12-34-56'.replace("-", ":")) // 12:34-56
+```
+
+There's a pitfall though.
+
+**When the first argument of `replace` is a string, it only looks for the first match.**
+
+You can see that in the example above: only the first `"-"` is replaced by `":"`.
+
+To find all dashes, we need to use not the string `"-"`, but a regexp `pattern:/-/g`, with an obligatory `g` flag:
+
+```js run
+// replace all dashes by a colon
+alert( '12-34-56'.replace( *!*/-/g*/!*, ":" ) )  // 12:34:56
+```
+
+The second argument is a replacement string. We can use special characters in it:
+
+| Symbol | Inserts |
+|--------|--------|
+|`$$`|`"$"` |
+|`$&`|the whole match|
+|<code>$&#096;</code>|a part of the string before the match|
+|`$'`|a part of the string after the match|
+|`$n`|if `n` is a 1-2 digit number, then it means the contents of n-th parentheses counting from left to right, otherwise it means a parentheses with the given name |
+
+
+For instance if we use `$&` in the replacement string, that means "put the whole match here".
+
+Let's use it to prepend all entries of `"John"` with `"Mr."`:
+
+```js run
+let str = "John Doe, John Smith and John Bull";
+
+// for each John - replace it with Mr. and then John
+alert(str.replace(/John/g, 'Mr.$&'));  // Mr.John Doe, Mr.John Smith and Mr.John Bull
+```
+
+Quite often we'd like to reuse parts of the source string, recombine them in the replacement or wrap into something.
+
+To do so, we should:
+1. First, mark the parts by parentheses in regexp.
+2. Use `$1`, `$2` (and so on) in the replacement string to get the content matched by parentheses.
+
+For instance:
+
+```js run
+let str = "John Smith";
+
+// swap first and last name
+alert(str.replace(/(john) (smith)/i, '$2, $1')) // Smith, John
+```
+
+**For situations that require "smart" replacements, the second argument can be a function.**
+
+It will be called for each match, and its result will be inserted as a replacement.
+
+For instance:
+
+```js run
+let i = 0;
+
+// replace each "ho" by the result of the function
+alert("HO-Ho-ho".replace(/ho/gi, function() {
+  return ++i;
+})); // 1-2-3
+```
+
+In the example above the function just returns the next number every time, but usually the result is based on the match.
+
+The function is called with arguments `func(str, p1, p2, ..., pn, offset, input, groups)`:
+
+1. `str` -- the match,
+2. `p1, p2, ..., pn` -- contents of parentheses (if there are any),
+3. `offset` -- position of the match,
+4. `input` -- the source string,
+5. `groups` -- an object with named groups (see chapter [](info:regexp-groups)).
+
+If there are no parentheses in the regexp, then there are only 3 arguments: `func(str, offset, input)`.
+
+Let's use it to show full information about matches:
+
+```js run
+// show and replace all matches
+function replacer(str, offset, input) {
+  alert(`Found ${str} at position ${offset} in string ${input}`);
+  return str.toLowerCase();
+}
+
+let result = "HO-Ho-ho".replace(/ho/gi, replacer);
+alert( 'Result: ' + result ); // Result: ho-ho-ho
+
+// shows each match:
+// Found HO at position 0 in string HO-Ho-ho
+// Found Ho at position 3 in string HO-Ho-ho
+// Found ho at position 6 in string HO-Ho-ho
+```
+
+In the example below there are two parentheses, so `replacer` is called with 5 arguments: `str` is the full match, then parentheses, and then `offset` and `input`:
+
+```js run
+function replacer(str, name, surname, offset, input) {
+  // name is the first parentheses, surname is the second one
+  return surname + ", " + name;
+}
+
+let str = "John Smith";
+
+alert(str.replace(/(John) (Smith)/, replacer)) // Smith, John
+```
+
+Using a function gives us the ultimate replacement power, because it gets all the information about the match, has access to outer variables and can do everything.
+
+## regexp.exec(str)
+
+We've already seen these searching methods:
+
+- `search` -- looks for the position of the match,
+- `match` -- if there's no `g` flag, returns the first match with parentheses and all details,
+- `match` -- if there's a `g` flag -- returns all matches, without details parentheses,
+- `matchAll` -- returns all matches with details.
+
+The `regexp.exec` method is the most flexible searching method of all. Unlike previous methods, `exec` should be called on a regexp, rather than on a string.
+
+It behaves differently depending on whether the regexp has the `g` flag.
+
+If there's no `g`, then `regexp.exec(str)` returns the first match, exactly as `str.match(reg)`. Such behavior does not give us anything new.
+
+But if there's `g`, then:
+- `regexp.exec(str)` returns the first match and *remembers* the position after it in `regexp.lastIndex` property.
+- The next call starts to search from `regexp.lastIndex` and returns the next match.
+- If there are no more matches then `regexp.exec` returns `null` and `regexp.lastIndex` is set to `0`.
+
+We could use it to get all matches with their positions and parentheses groups in a loop, instead of `matchAll`:
+
+```js run
+let str = 'A lot about JavaScript at https://javascript.info';
+
+let regexp = /javascript/ig;
+
+let result;
+
+while (result = regexp.exec(str)) {
+  alert( `Found ${result[0]} at ${result.index}` );
+  // shows: Found JavaScript at 12, then:
+  // shows: Found javascript at 34
+}
+```
+
+Surely, `matchAll` does the same, at least for modern browsers. But what `matchAll` can't do -- is to search from a given position.
+
+Let's search from position `13`. What we need is to assign `regexp.lastIndex=13` and call `regexp.exec`:
+
+```js run
+let str = "A lot about JavaScript at https://javascript.info";
+
+let regexp = /javascript/ig;
+*!*
+regexp.lastIndex = 13;
+*/!*
+
+let result;
+
+while (result = regexp.exec(str)) {
+  alert( `Found ${result[0]} at ${result.index}` );
+  // shows: Found javascript at 34
+}
+```
+
+Now, starting from the given position `13`, there's only one match.
+
+
+## regexp.test(str)
+
+The method `regexp.test(str)` looks for a match and returns `true/false` whether it finds it.
+
+For instance:
+
+```js run
+let str = "I love JavaScript";
+
+// these two tests do the same
+alert( *!*/love/i*/!*.test(str) ); // true
+alert( str.search(*!*/love/i*/!*) != -1 ); // true
+```
+
+An example with the negative answer:
+
+```js run
+let str = "Bla-bla-bla";
+
+alert( *!*/love/i*/!*.test(str) ); // false
+alert( str.search(*!*/love/i*/!*) != -1 ); // false
+```
+
+If the regexp has `'g'` flag, then `regexp.test` advances `regexp.lastIndex` property, just like `regexp.exec`.
+
+So we can use it to search from a given position:
+
+```js run
+let regexp = /love/gi;
+
+let str = "I love JavaScript";
+
+// start the search from position 10:
+regexp.lastIndex = 10
+alert( regexp.test(str) ); // false (no match)
+```
+
+
+
+````warn header="Same global regexp tested repeatedly may fail to match"
+If we apply the same global regexp to different inputs, it may lead to wrong result, because `regexp.test` call advances `regexp.lastIndex` property, so next matches start from non-zero position.
+
+For instance, here we call `regexp.test` twice on the same text, and the second time fails:
+
+```js run
+let regexp = /javascript/g;  // (regexp just created: regexp.lastIndex=0)
+
+alert( regexp.test("javascript") ); // true (regexp.lastIndex=10 now)
+alert( regexp.test("javascript") ); // false
+```
+
+That's exactly because `regexp.lastIndex` is non-zero on the second test.
+
+To work around that, one could use non-global regexps or re-adjust `regexp.lastIndex=0` before a new search.
+````
+
+## Summary
+
+There's a variety of many methods on both regexps and strings.
+
+Their abilities and methods overlap quite a bit, we can do the same by different calls. Sometimes that may cause confusion when starting to learn the language.
+
+Then please refer to the recipes at the beginning of this chapter, as they provide solutions for the majority of regexp-related tasks.
diff --git a/5-regular-expressions/03-regexp-character-classes/1-find-time-hh-mm/solution.md b/9-regular-expressions/03-regexp-character-classes/1-find-time-hh-mm/solution.md
similarity index 100%
rename from 5-regular-expressions/03-regexp-character-classes/1-find-time-hh-mm/solution.md
rename to 9-regular-expressions/03-regexp-character-classes/1-find-time-hh-mm/solution.md
diff --git a/5-regular-expressions/03-regexp-character-classes/1-find-time-hh-mm/task.md b/9-regular-expressions/03-regexp-character-classes/1-find-time-hh-mm/task.md
similarity index 100%
rename from 5-regular-expressions/03-regexp-character-classes/1-find-time-hh-mm/task.md
rename to 9-regular-expressions/03-regexp-character-classes/1-find-time-hh-mm/task.md
diff --git a/5-regular-expressions/03-regexp-character-classes/article.md b/9-regular-expressions/03-regexp-character-classes/article.md
similarity index 54%
rename from 5-regular-expressions/03-regexp-character-classes/article.md
rename to 9-regular-expressions/03-regexp-character-classes/article.md
index 2b41d57e4..c1bc1bad5 100644
--- a/5-regular-expressions/03-regexp-character-classes/article.md
+++ b/9-regular-expressions/03-regexp-character-classes/article.md
@@ -1,12 +1,14 @@
 # Character classes
 
-Consider a practical task -- we have a phone number `"+7(903)-123-45-67"`, and we need to find all digits in that string. Other characters do not interest us.
+Consider a practical task -- we have a phone number `"+7(903)-123-45-67"`, and we need to turn it into pure numbers: `79035419441`.
 
-A character class is a special notation that matches any symbol from the set.
+To do so, we can find and remove anything that's not a number. Character classes can help with that.
 
-For instance, there's a "digit" class. It's written as `\d`. We put it in the pattern, and during the search any digit matches it.
+A character class is a special notation that matches any symbol from a certain set.
 
-For instance, the regexp `pattern:/\d/` looks for a single digit:
+For the start, let's explore a "digit" class. It's written as `\d`. We put it in the pattern, that means "any single digit".
+
+For instance, the let's find the first digit in the phone number:
 
 ```js run
 let str = "+7(903)-123-45-67";
@@ -16,9 +18,9 @@ let reg = /\d/;
 alert( str.match(reg) ); // 7
 ```
 
-The regexp is not global in the example above, so it only looks for the first match.
+Without the flag `g`, the regular expression only looks for the first match, that is the first digit `\d`.
 
-Let's add the `g` flag to look for all digits:
+Let's add the `g` flag to find all digits:
 
 ```js run
 let str = "+7(903)-123-45-67";
@@ -26,9 +28,9 @@ let str = "+7(903)-123-45-67";
 let reg = /\d/g;
 
 alert( str.match(reg) ); // array of matches: 7,9,0,3,1,2,3,4,5,6,7
-```
 
-## Most used classes: \d \s \w
+alert( str.match(reg).join('') ); // 79035419441
+```
 
 That was a character class for digits. There are other character classes as well.
 
@@ -43,9 +45,9 @@ Most used are:
 `\w` ("w" is from "word")
 : A "wordly" character: either a letter of English alphabet or a digit or an underscore. Non-english letters (like cyrillic or hindi) do not belong to `\w`.
 
-For instance, `pattern:\d\s\w` means a digit followed by a space character followed by a wordly character, like `"1 Z"`.
+For instance, `pattern:\d\s\w` means a "digit" followed by a "space character" followed by a "wordly character", like `"1 a"`.
 
-A regexp may contain both regular symbols and character classes.
+**A regexp may contain both regular symbols and character classes.**
 
 For instance, `pattern:CSS\d` matches a string `match:CSS` with a digit after it:
 
@@ -68,7 +70,7 @@ The match (each character class corresponds to one result character):
 
 ## Word boundary: \b
 
-The word boundary `pattern:\b` -- is a special character class.
+A word boundary `pattern:\b` -- is a special character class.
 
 It does not denote a character, but rather a boundary between characters.
 
@@ -79,29 +81,36 @@ alert( "Hello, Java!".match(/\bJava\b/) ); // Java
 alert( "Hello, JavaScript!".match(/\bJava\b/) ); // null
 ```
 
-The boundary has "zero width" in a sense that usually a character class means a character in the result (like a wordly or a digit), but not in this case.
+The boundary has "zero width" in a sense that usually a character class means a character in the result (like a wordly character or a digit), but not in this case.
 
 The boundary is a test.
 
 When regular expression engine is doing the search, it's moving along the string in an attempt to find the match. At each string position it tries to find the pattern.
 
-When the pattern contains `pattern:\b`, it tests that the position in string fits one of the conditions:
+When the pattern contains `pattern:\b`, it tests that the position in string is a word boundary, that is one of three variants:
 
-- String start, and the first string character is `\w`.
-- String end, and the last string character is `\w`.
-- Inside the string: from one side is `\w`, from the other side -- not `\w`.
+- Immediately before is `\w`, and immediately after -- not `\w`, or vise versa.
+- At string start, and the first string character is `\w`.
+- At string end, and the last string character is `\w`.
 
 For instance, in the string `subject:Hello, Java!` the following positions match `\b`:
 
 ![](hello-java-boundaries.png)
 
-So it matches `pattern:\bHello\b` and `pattern:\bJava\b`, but not `pattern:\bHell\b` (because there's no word boundary after `l`) and not `Java!\b` (because the exclamation sign is not a wordly character, so there's no word boundary after it).
+So it matches `pattern:\bHello\b`, because:
+
+1. At the beginning of the string the first `\b` test matches.
+2. Then the word `Hello` matches.
+3. Then `\b` matches, as we're between `o` and a space.
+
+Pattern `pattern:\bJava\b` also matches. But not `pattern:\bHell\b` (because there's no word boundary after `l`) and not `Java!\b` (because the exclamation sign is not a wordly character, so there's no word boundary after it).
+
 
 ```js run
 alert( "Hello, Java!".match(/\bHello\b/) ); // Hello
 alert( "Hello, Java!".match(/\bJava\b/) );  // Java
-alert( "Hello, Java!".match(/\bHell\b/) );  // null
-alert( "Hello, Java!".match(/\bJava!\b/) ); // null
+alert( "Hello, Java!".match(/\bHell\b/) );  // null (no match)
+alert( "Hello, Java!".match(/\bJava!\b/) ); // null (no match)
 ```
 
 Once again let's note that `pattern:\b` makes the searching engine to test for the boundary, so that `pattern:Java\b` finds `match:Java` only when followed by a word boundary, but it does not add a letter to the result.
@@ -119,9 +128,9 @@ The word boundary check `\b` tests for a boundary between `\w` and something els
 ```
 
 
-## Reverse classes
+## Inverse classes
 
-For every character class there exists a "reverse class", denoted with the same letter, but uppercased.
+For every character class there exists an "inverse class", denoted with the same letter, but uppercased.
 
 The "reverse" means that it matches all other characters, for instance:
 
@@ -137,7 +146,9 @@ The "reverse" means that it matches all other characters, for instance:
 `\B`
 : Non-boundary: a test reverse to `\b`.
 
-In the beginning of the chapter we saw how to get all digits from the phone `subject:+7(903)-123-45-67`. Let's get a "pure" phone number from the string:
+In the beginning of the chapter we saw how to get all digits from the phone `subject:+7(903)-123-45-67`.
+
+One way was to match all digits and join them:
 
 ```js run
 let str = "+7(903)-123-45-67";
@@ -145,7 +156,7 @@ let str = "+7(903)-123-45-67";
 alert( str.match(/\d/g).join('') ); // 79031234567
 ```
 
-An alternative way would be to find non-digits and remove them from the string:
+An alternative, shorter way is to find non-digits `\D` and remove them from the string:
 
 
 ```js run
@@ -156,11 +167,9 @@ alert( str.replace(/\D/g, "") ); // 79031234567
 
 ## Spaces are regular characters
 
-Please note that regular expressions may include spaces. They are treated like regular characters.  
-
 Usually we pay little attention to spaces. For us strings `subject:1-5` and `subject:1 - 5` are nearly identical.
 
-But if a regexp does not take spaces into account, it won' work.
+But if a regexp doesn't take spaces into account, it may fail to work.
 
 Let's try to find digits separated by a dash:
 
@@ -168,23 +177,25 @@ Let's try to find digits separated by a dash:
 alert( "1 - 5".match(/\d-\d/) ); // null, no match!
 ```
 
-Here we fix it by adding spaces into the regexp:
+Here we fix it by adding spaces into the regexp `pattern:\d - \d`:
 
 ```js run
 alert( "1 - 5".match(/\d - \d/) ); // 1 - 5, now it works
 ```
 
-Of course, spaces are needed only if we look for them. Extra spaces (just like any other extra characters) may prevent a match:
+**A space is a character. Equal in importance with any other character.**
+
+Of course, spaces in a regexp are needed only if we look for them. Extra spaces (just like any other extra characters) may prevent a match:
 
 ```js run
 alert( "1-5".match(/\d - \d/) ); // null, because the string 1-5 has no spaces
 ```
 
-In other words, in a regular expression all characters matter. Spaces too.
+In other words, in a regular expression all characters matter, spaces too.
 
 ## A dot is any character
 
-The dot `"."` is a special character class that matches *any character except a newline*.
+The dot `"."` is a special character class that matches "any character except a newline".
 
 For instance:
 
@@ -208,19 +219,47 @@ Please note that the dot means "any character", but not the "absense of a charac
 alert( "CS4".match(/CS.4/) ); // null, no match because there's no character for the dot
 ```
 
+### The dotall "s" flag
+
+Usually a dot doesn't match a newline character.
+
+For instance, this doesn't match:
+
+```js run
+alert( "A\nB".match(/A.B/) ); // null (no match)
+
+// a space character would match
+// or a letter, but not \n
+```
+
+Sometimes it's inconvenient, we really want "any character", newline included.
+
+That's what `s` flag does. If a regexp has it, then the dot `"."` match literally any character:
+
+```js run
+alert( "A\nB".match(/A.B/s) ); // A\nB (match!)
+```
+
 
 ## Summary
 
-We covered character classes:
+There exist following character classes:
+
+- `pattern:\d` -- digits.
+- `pattern:\D` -- non-digits.
+- `pattern:\s` -- space symbols, tabs, newlines.
+- `pattern:\S` -- all but `pattern:\s`.
+- `pattern:\w` -- English letters, digits, underscore `'_'`.
+- `pattern:\W` -- all but `pattern:\w`.
+- `pattern:.` -- any character if with the regexp `'s'` flag, otherwise any except a newline.
+
+...But that's not all!
 
-- `\d` -- digits.
-- `\D` -- non-digits.
-- `\s` -- space symbols, tabs, newlines.
-- `\S` -- all but `\s`.
-- `\w` -- English letters, digits, underscore `'_'`.
-- `\W` -- all but `\w`.
-- `'.'` -- any character except a newline.
+Modern JavaScript also allows to look for characters by their Unicode properties, for instance:
 
-If we want to search for a character that has a special meaning like a backslash or a dot, then we should escape it with a backslash: `pattern:\.`
+- A cyrillic letter is: `pattern:\p{Script=Cyrillic}` or `pattern:\p{sc=Cyrillic}`.
+- A dash (be it a small hyphen `-` or a long dash `—`): `pattern:\p{Dash_Punctuation}` or `pattern:\p{pd}`.
+- A currency symbol: `pattern:\p{Currency_Symbol}` or `pattern:\p{sc}`.
+- ...And much more. Unicode has a lot of character categories that we can select from.
 
-Please note that a regexp may also contain string special characters such as a newline `\n`. There's no conflict with character classes, because other letters are used for them.
+These patterns require `'u'` regexp flag to work. More about that in the chapter [](info:regexp-unicode).
diff --git a/9-regular-expressions/03-regexp-character-classes/hello-java-boundaries.png b/9-regular-expressions/03-regexp-character-classes/hello-java-boundaries.png
new file mode 100644
index 000000000..46fc686ba
Binary files /dev/null and b/9-regular-expressions/03-regexp-character-classes/hello-java-boundaries.png differ
diff --git a/9-regular-expressions/03-regexp-character-classes/hello-java-boundaries@2x.png b/9-regular-expressions/03-regexp-character-classes/hello-java-boundaries@2x.png
new file mode 100644
index 000000000..9beafe707
Binary files /dev/null and b/9-regular-expressions/03-regexp-character-classes/hello-java-boundaries@2x.png differ
diff --git a/9-regular-expressions/03-regexp-character-classes/love-html5-classes.png b/9-regular-expressions/03-regexp-character-classes/love-html5-classes.png
new file mode 100644
index 000000000..8f9daefdd
Binary files /dev/null and b/9-regular-expressions/03-regexp-character-classes/love-html5-classes.png differ
diff --git a/9-regular-expressions/03-regexp-character-classes/love-html5-classes@2x.png b/9-regular-expressions/03-regexp-character-classes/love-html5-classes@2x.png
new file mode 100644
index 000000000..438c6bc22
Binary files /dev/null and b/9-regular-expressions/03-regexp-character-classes/love-html5-classes@2x.png differ
diff --git a/9-regular-expressions/04-regexp-escaping/article.md b/9-regular-expressions/04-regexp-escaping/article.md
new file mode 100644
index 000000000..48f4a810d
--- /dev/null
+++ b/9-regular-expressions/04-regexp-escaping/article.md
@@ -0,0 +1,99 @@
+
+# Escaping, special characters
+
+As we've seen, a backslash `"\"` is used to denote character classes. So it's a special character in regexps (just like in a regular string).
+
+There are other special characters as well, that have special meaning in a regexp. They are used to do more powerful searches. Here's a full list of them: `pattern:[ \ ^ $ . | ? * + ( )`.
+
+Don't try to remember the list -- soon we'll deal with each of them separately and you'll know them by heart automatically.
+
+## Escaping
+
+Let's say we want to find a dot literally. Not "any character", but just a dot.
+
+To use a special character as a regular one, prepend it with a backslash: `pattern:\.`.
+
+That's also called "escaping a character".
+
+For example:
+```js run
+alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
+alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
+```
+
+Parentheses are also special characters, so if we want them, we should use `pattern:\(`. The example below looks for a string `"g()"`:
+
+```js run
+alert( "function g()".match(/g\(\)/) ); // "g()"
+```
+
+If we're looking for a backslash `\`, it's a special character in both regular strings and regexps, so we should double it.
+
+```js run
+alert( "1\\2".match(/\\/) ); // '\'
+```
+
+## A slash
+
+A slash symbol `'/'` is not a special character, but in JavaScript it is used to open and close the regexp: `pattern:/...pattern.../`, so we should escape it too.
+
+Here's what a search for a slash `'/'` looks like:
+
+```js run
+alert( "/".match(/\//) ); // '/'
+```
+
+On the other hand, if we're not using `/.../`, but create a regexp using `new RegExp`, then we don't need to escape it:
+
+```js run
+alert( "/".match(new RegExp("/")) ); // '/'
+```                                                                                                                                                                                   
+
+## new RegExp
+
+If we are creating a regular expression with `new RegExp`, then we don't have to escape `/`, but need to do some other escaping.
+
+For instance, consider this:
+
+```js run
+let reg = new RegExp("\d\.\d");
+
+alert( "Chapter 5.1".match(reg) ); // null
+```
+
+It worked with `pattern:/\d\.\d/`, but with `new RegExp("\d\.\d")` it doesn't, why?
+
+The reason is that backslashes are "consumed" by a string. Remember, regular strings have their own special characters like `\n`, and a backslash is used for escaping.
+
+Please, take a look, what "\d\.\d" really is:
+
+```js run
+alert("\d\.\d"); // d.d
+```
+
+The quotes "consume" backslashes and interpret them, for instance:
+
+- `\n` -- becomes a newline character,
+- `\u1234` -- becomes the Unicode character with such code,
+- ...And when there's no special meaning: like `\d` or `\z`, then the backslash is simply removed.
+
+So the call to `new RegExp` gets a string without backslashes. That's why it doesn't work!
+
+To fix it, we need to double backslashes, because quotes turn `\\` into `\`:
+
+```js run
+*!*
+let regStr = "\\d\\.\\d";
+*/!*
+alert(regStr); // \d\.\d (correct now)
+
+let reg = new RegExp(regStr);
+
+alert( "Chapter 5.1".match(reg) ); // 5.1
+```
+
+## Summary
+
+- To search special characters `pattern:[ \ ^ $ . | ? * + ( )` literally, we need to prepend them with `\` ("escape them").
+- We also need to escape `/` if we're inside `pattern:/.../` (but not inside `new RegExp`).
+- When passing a string `new RegExp`, we need to double backslashes `\\`, cause strings consume one of them.
diff --git a/5-regular-expressions/05-regexp-character-sets-and-ranges/1-find-range-1/solution.md b/9-regular-expressions/05-regexp-character-sets-and-ranges/1-find-range-1/solution.md
similarity index 100%
rename from 5-regular-expressions/05-regexp-character-sets-and-ranges/1-find-range-1/solution.md
rename to 9-regular-expressions/05-regexp-character-sets-and-ranges/1-find-range-1/solution.md
diff --git a/5-regular-expressions/05-regexp-character-sets-and-ranges/1-find-range-1/task.md b/9-regular-expressions/05-regexp-character-sets-and-ranges/1-find-range-1/task.md
similarity index 100%
rename from 5-regular-expressions/05-regexp-character-sets-and-ranges/1-find-range-1/task.md
rename to 9-regular-expressions/05-regexp-character-sets-and-ranges/1-find-range-1/task.md
diff --git a/5-regular-expressions/05-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md b/9-regular-expressions/05-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
similarity index 100%
rename from 5-regular-expressions/05-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
rename to 9-regular-expressions/05-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
diff --git a/5-regular-expressions/05-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md b/9-regular-expressions/05-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
similarity index 100%
rename from 5-regular-expressions/05-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
rename to 9-regular-expressions/05-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
diff --git a/5-regular-expressions/05-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/05-regexp-character-sets-and-ranges/article.md
similarity index 100%
rename from 5-regular-expressions/05-regexp-character-sets-and-ranges/article.md
rename to 9-regular-expressions/05-regexp-character-sets-and-ranges/article.md
diff --git a/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/solution.md b/9-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/solution.md
similarity index 100%
rename from 5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/solution.md
rename to 9-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/solution.md
diff --git a/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md b/9-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md
similarity index 100%
rename from 5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md
rename to 9-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md
diff --git a/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/solution.md b/9-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/solution.md
similarity index 100%
rename from 5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/solution.md
rename to 9-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/solution.md
diff --git a/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/task.md b/9-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/task.md
similarity index 100%
rename from 5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/task.md
rename to 9-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/task.md
diff --git a/5-regular-expressions/07-regexp-quantifiers/article.md b/9-regular-expressions/07-regexp-quantifiers/article.md
similarity index 66%
rename from 5-regular-expressions/07-regexp-quantifiers/article.md
rename to 9-regular-expressions/07-regexp-quantifiers/article.md
index 6b6933bb4..5ab592561 100644
--- a/5-regular-expressions/07-regexp-quantifiers/article.md
+++ b/9-regular-expressions/07-regexp-quantifiers/article.md
@@ -1,16 +1,18 @@
 # Quantifiers +, *, ? and {n}
 
-Let's say we have a string like `+7(903)-123-45-67` and want to find all numbers in it. But unlike before, we are interested in not digits, but full numbers: `7, 903, 123, 45, 67`.
+Let's say we have a string like `+7(903)-123-45-67` and want to find all numbers in it. But unlike before, we are interested not in single digits, but full numbers: `7, 903, 123, 45, 67`.
 
-A number is a sequence of 1 or more digits `\d`. The instrument to say how many we need is called *quantifiers*.
+A number is a sequence of 1 or more digits `\d`. To mark how many we need, we need to append a *quantifier*.
 
 ## Quantity {n}
 
-The most obvious quantifier is a number in figure quotes: `pattern:{n}`. A quantifier is put after a character (or a character class and so on) and specifies exactly how many we need.
+The simplest quantifier is a number in curly braces: `pattern:{n}`.
 
-It also has advanced forms, here we go with examples:
+A quantifier is appended to a character (or a character class, or a `[...]` set etc) and specifies how many we need.
 
-Exact count: `{5}`
+It has a few advanced forms, let's see examples:
+
+The exact count: `{5}`
 : `pattern:\d{5}` denotes exactly 5 digits, the same as `pattern:\d\d\d\d\d`.
 
     The example below looks for a 5-digit number:
@@ -21,20 +23,24 @@ Exact count: `{5}`
 
     We can add `\b` to exclude longer numbers: `pattern:\b\d{5}\b`.
 
-The count from-to: `{3,5}`
-: To find numbers from 3 to 5 digits we can put the limits into figure brackets: `pattern:\d{3,5}`
+The range: `{3,5}`, match 3-5 times
+: To find numbers from 3 to 5 digits we can put the limits into curly braces: `pattern:\d{3,5}`
 
     ```js run
     alert( "I'm not 12, but 1234 years old".match(/\d{3,5}/) ); // "1234"
     ```
 
-    We can omit the upper limit. Then a regexp `pattern:\d{3,}` looks for numbers of `3` and more digits:
+    We can omit the upper limit.
+
+    Then a regexp `pattern:\d{3,}` looks for sequences of digits of length `3` or more:
 
     ```js run
     alert( "I'm not 12, but 345678 years old".match(/\d{3,}/) ); // "345678"
     ```
 
-In case with the string `+7(903)-123-45-67` we need numbers: one or more digits in a row. That is  `pattern:\d{1,}`:
+Let's return to the string `+7(903)-123-45-67`.
+
+A number is a sequence of one or more digits in a row. So the regexp is `pattern:\d{1,}`:
 
 ```js run
 let str = "+7(903)-123-45-67";
@@ -46,7 +52,7 @@ alert(numbers); // 7,903,123,45,67
 
 ## Shorthands
 
-Most often needed quantifiers have shorthands:
+There are shorthands for most used quantifiers:
 
 `+`
 : Means "one or more", the same as `{1,}`.
@@ -64,7 +70,7 @@ Most often needed quantifiers have shorthands:
 
     For instance, the pattern `pattern:ou?r` looks for `match:o` followed by zero or one `match:u`, and then `match:r`.
 
-    So it can find `match:or` in the word `subject:color` and `match:our` in `subject:colour`:
+    So, `pattern:colou?r` finds both `match:color` and `match:colour`:
 
     ```js run
     let str = "Should I write color or colour?";
@@ -75,7 +81,7 @@ Most often needed quantifiers have shorthands:
 `*`
 : Means "zero or more", the same as `{0,}`. That is, the character may repeat any times or be absent.
 
-    The example below looks for a digit followed by any number of zeroes:
+    For example, `pattern:\d0*` looks for a digit followed by any number of zeroes:
 
     ```js run
     alert( "100 10 1".match(/\d0*/g) ); // 100, 10, 1
@@ -85,11 +91,12 @@ Most often needed quantifiers have shorthands:
 
     ```js run
     alert( "100 10 1".match(/\d0+/g) ); // 100, 10
+    // 1 not matched, as 0+ requires at least one zero
     ```
 
 ## More examples
 
-Quantifiers are used very often. They are one of the main "building blocks" for complex regular expressions, so let's see more examples.
+Quantifiers are used very often. They serve as the main "building block" of complex regular expressions, so let's see more examples.
 
 Regexp "decimal fraction" (a number with a floating point): `pattern:\d+\.\d+`
 : In action:
@@ -120,12 +127,12 @@ Regexp "opening or closing HTML-tag without attributes": `pattern:/<\/?[a-z][a-z
     alert( "<h1>Hi!</h1>".match(/<\/?[a-z][a-z0-9]*>/gi) ); // <h1>, </h1>
     ```
 
-```smart header="More precise means more complex"
+```smart header="To make a regexp more precise, we often need make it more complex"
 We can see one common rule in these examples: the more precise is the regular expression -- the longer and more complex it is.
 
-For instance, HTML tags could use a simpler regexp: `pattern:<\w+>`.
+For instance, for HTML tags we could use a simpler regexp: `pattern:<\w+>`.
 
-Because `pattern:\w` means any English letter or a digit or `'_'`, the regexp also matches non-tags, for instance `match:<_>`. But it's much simpler than `pattern:<[a-z][a-z0-9]*>`.
+...But because `pattern:\w` means any English letter or a digit or `'_'`, the regexp also matches non-tags, for instance `match:<_>`. So it's much simpler than `pattern:<[a-z][a-z0-9]*>`, but less reliable.
 
 Are we ok with `pattern:<\w+>` or we need `pattern:<[a-z][a-z0-9]*>`?
 
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/1-lazy-greedy/solution.md b/9-regular-expressions/08-regexp-greedy-and-lazy/1-lazy-greedy/solution.md
similarity index 100%
rename from 5-regular-expressions/08-regexp-greedy-and-lazy/1-lazy-greedy/solution.md
rename to 9-regular-expressions/08-regexp-greedy-and-lazy/1-lazy-greedy/solution.md
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/1-lazy-greedy/task.md b/9-regular-expressions/08-regexp-greedy-and-lazy/1-lazy-greedy/task.md
similarity index 100%
rename from 5-regular-expressions/08-regexp-greedy-and-lazy/1-lazy-greedy/task.md
rename to 9-regular-expressions/08-regexp-greedy-and-lazy/1-lazy-greedy/task.md
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/3-find-html-comments/solution.md b/9-regular-expressions/08-regexp-greedy-and-lazy/3-find-html-comments/solution.md
similarity index 88%
rename from 5-regular-expressions/08-regexp-greedy-and-lazy/3-find-html-comments/solution.md
rename to 9-regular-expressions/08-regexp-greedy-and-lazy/3-find-html-comments/solution.md
index b36eec4a0..c066f3e36 100644
--- a/5-regular-expressions/08-regexp-greedy-and-lazy/3-find-html-comments/solution.md
+++ b/9-regular-expressions/08-regexp-greedy-and-lazy/3-find-html-comments/solution.md
@@ -2,7 +2,7 @@ We need to find the beginning of the comment `match:<!--`, then everything till
 
 The first idea could be `pattern:<!--.*?-->` -- the lazy quantifier makes the dot stop right before  `match:-->`.
 
-But a dot in Javascript means "any symbol except the newline". So multiline comments won't be found.
+But a dot in JavaScript means "any symbol except the newline". So multiline comments won't be found.
 
 We can use `pattern:[\s\S]` instead of the dot to match "anything":
 
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/3-find-html-comments/task.md b/9-regular-expressions/08-regexp-greedy-and-lazy/3-find-html-comments/task.md
similarity index 100%
rename from 5-regular-expressions/08-regexp-greedy-and-lazy/3-find-html-comments/task.md
rename to 9-regular-expressions/08-regexp-greedy-and-lazy/3-find-html-comments/task.md
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/4-find-html-tags-greedy-lazy/solution.md b/9-regular-expressions/08-regexp-greedy-and-lazy/4-find-html-tags-greedy-lazy/solution.md
similarity index 100%
rename from 5-regular-expressions/08-regexp-greedy-and-lazy/4-find-html-tags-greedy-lazy/solution.md
rename to 9-regular-expressions/08-regexp-greedy-and-lazy/4-find-html-tags-greedy-lazy/solution.md
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/4-find-html-tags-greedy-lazy/task.md b/9-regular-expressions/08-regexp-greedy-and-lazy/4-find-html-tags-greedy-lazy/task.md
similarity index 100%
rename from 5-regular-expressions/08-regexp-greedy-and-lazy/4-find-html-tags-greedy-lazy/task.md
rename to 9-regular-expressions/08-regexp-greedy-and-lazy/4-find-html-tags-greedy-lazy/task.md
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/article.md b/9-regular-expressions/08-regexp-greedy-and-lazy/article.md
similarity index 88%
rename from 5-regular-expressions/08-regexp-greedy-and-lazy/article.md
rename to 9-regular-expressions/08-regexp-greedy-and-lazy/article.md
index 710408216..f7c6de43d 100644
--- a/5-regular-expressions/08-regexp-greedy-and-lazy/article.md
+++ b/9-regular-expressions/08-regexp-greedy-and-lazy/article.md
@@ -8,15 +8,13 @@ Let's take the following task as an example.
 
 We have a text and need to replace all quotes `"..."` with guillemet marks: `«...»`. They are preferred for typography in many countries.
 
-For instance: `"Hello, world"` should become `«Hello, world»`.
+For instance: `"Hello, world"` should become `«Hello, world»`. Some countries prefer other quotes, like `„Witam, świat!”` (Polish) or `「你好，世界」` (Chinese), but for our task let's choose `«...»`.
 
-Some countries prefer `„Witam, świat!”` (Polish) or even `「你好，世界」` (Chinese) quotes. For different locales we can choose different replacements, but that all works the same, so let's start with `«...»`.
+The first thing to do is to locate quoted strings, and then we can replace them.
 
-To make replacements we first need to find all quoted substrings.
+A regular expression like `pattern:/".+"/g` (a quote, then something, then the other quote) may seem like a good fit, but it isn't!
 
-The regular expression can look like this: `pattern:/".+"/g`. That is: we look for a quote followed by one or more characters, and then another quote.
-
-...But if we try to apply it, even in such a simple case...
+Let's try it:
 
 ```js run
 let reg = /".+"/g;
@@ -193,7 +191,7 @@ Please note, that this logic does not replace lazy quantifiers!
 
 It is just different. There are times when we need one or another.
 
-Let's see one more example where lazy quantifiers fail and this variant works right.
+**Let's see an example where lazy quantifiers fail and this variant works right.**
 
 For instance, we want to find links of the form `<a href="..." class="doc">`, with any `href`.
 
@@ -210,7 +208,7 @@ let reg = /<a href=".*" class="doc">/g;
 alert( str.match(reg) ); // <a href="link" class="doc">
 ```
 
-...But what if there are many links in the text?
+It worked. But let's see what happens if there are many links in the text?
 
 ```js run
 let str = '...<a href="link1" class="doc">... <a href="link2" class="doc">...';
@@ -239,14 +237,14 @@ let reg = /<a href=".*?" class="doc">/g;
 alert( str.match(reg) ); // <a href="link1" class="doc">, <a href="link2" class="doc">
 ```
 
-Now it works, there are two matches:
+Now it seems to work, there are two matches:
 
 ```html
 <a href="....." class="doc">    <a href="....." class="doc">
 <a href="link1" class="doc">... <a href="link2" class="doc">
 ```
 
-Why it works -- should be obvious after all explanations above. So let's not stop on the details, but try one more text:
+...But let's test it on one more text input:
 
 ```js run
 let str = '...<a href="link1" class="wrong">... <p style="" class="doc">...';
@@ -256,24 +254,24 @@ let reg = /<a href=".*?" class="doc">/g;
 alert( str.match(reg) ); // <a href="link1" class="wrong">... <p style="" class="doc">
 ```
 
-We can see that the regexp matched not just a link, but also a lot of text after it, including `<p...>`.
-
-Why it happens?
+Now it fails. The match includes not just a link, but also a lot of text after it, including `<p...>`.
 
-1. First the regexp finds a link start `match:<a href="`.
+Why?
 
-2. Then it looks for `pattern:.*?`, we take one character, then check if there's a match for the rest of the pattern, then take another one...
+That's what's going on:
 
-    The quantifier `pattern:.*?` consumes characters until it meets `match:class="doc">`.
+1. First the regexp finds a link start `match:<a href="`.
+2. Then it looks for `pattern:.*?`: takes one character (lazily!), check if there's a match for `pattern:" class="doc">` (none).
+3. Then takes another character into `pattern:.*?`, and so on... until it finally reaches `match:" class="doc">`.
 
-    ...And where can it find it? If we look at the text, then we can see that the only `match:class="doc">` is beyond the link, in the tag `<p>`.
+But the problem is: that's already beyound the link, in another tag `<p>`. Not what we want.
 
-3. So we have match:
+Here's the picture of the match aligned with the text:
 
-    ```html
-    <a href="..................................." class="doc">
-    <a href="link1" class="wrong">... <p style="" class="doc">
-    ```
+```html
+<a href="..................................." class="doc">
+<a href="link1" class="wrong">... <p style="" class="doc">
+```
 
 So the laziness did not work for us here.
 
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy1.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy1.png
new file mode 100644
index 000000000..d2ed3d55a
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy1.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy1@2x.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy1@2x.png
new file mode 100644
index 000000000..e1e6076d3
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy1@2x.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy2.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy2.png
new file mode 100644
index 000000000..175636ced
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy2.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy2@2x.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy2@2x.png
new file mode 100644
index 000000000..e3c3d7591
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy2@2x.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy3.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy3.png
new file mode 100644
index 000000000..d879244a9
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy3.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy3@2x.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy3@2x.png
new file mode 100644
index 000000000..3594f91ba
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy3@2x.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy4.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy4.png
new file mode 100644
index 000000000..2a571b0d8
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy4.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy4@2x.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy4@2x.png
new file mode 100644
index 000000000..9fd709e8b
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy4@2x.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy5.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy5.png
new file mode 100644
index 000000000..ae1528aa9
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy5.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy5@2x.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy5@2x.png
new file mode 100644
index 000000000..f17edceb0
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy5@2x.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy6.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy6.png
new file mode 100644
index 000000000..5fd767c6a
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy6.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy6@2x.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy6@2x.png
new file mode 100644
index 000000000..10bdfb8c7
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_greedy6@2x.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy3.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy3.png
new file mode 100644
index 000000000..af5416a72
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy3.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy3@2x.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy3@2x.png
new file mode 100644
index 000000000..27e272590
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy3@2x.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy4.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy4.png
new file mode 100644
index 000000000..c6dbdc926
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy4.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy4@2x.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy4@2x.png
new file mode 100644
index 000000000..4fdbd99a6
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy4@2x.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy5.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy5.png
new file mode 100644
index 000000000..04f91fbba
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy5.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy5@2x.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy5@2x.png
new file mode 100644
index 000000000..7a2864311
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy5@2x.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy6.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy6.png
new file mode 100644
index 000000000..d2e41d458
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy6.png differ
diff --git a/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy6@2x.png b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy6@2x.png
new file mode 100644
index 000000000..49dc2cd8e
Binary files /dev/null and b/9-regular-expressions/08-regexp-greedy-and-lazy/witch_lazy6@2x.png differ
diff --git a/5-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
similarity index 100%
rename from 5-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
rename to 9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
diff --git a/5-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md
similarity index 100%
rename from 5-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md
rename to 9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md
diff --git a/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md b/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md
new file mode 100644
index 000000000..23065413e
--- /dev/null
+++ b/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md
@@ -0,0 +1,18 @@
+
+An non-negative integer number is `pattern:\d+`. We should exclude `0` as the first digit, as we don't need zero, but we can allow it in further digits.
+
+So that gives us `pattern:[1-9]\d*`.
+
+A decimal part is: `pattern:\.\d+`.
+
+Because the decimal part is optional, let's put it in parentheses with the quantifier `pattern:'?'`.
+
+Finally we have the regexp: `pattern:[1-9]\d*(\.\d+)?`:
+
+```js run
+let reg = /[1-9]\d*(\.\d+)?/g;
+
+let str = "1.5 0 -5 12. 123.4.";
+
+alert( str.match(reg) );   // 1.5, 0, 12, 123.4
+```
diff --git a/5-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/task.md b/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/task.md
similarity index 64%
rename from 5-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/task.md
rename to 9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/task.md
index 2ce178760..ad8c81eae 100644
--- a/5-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/task.md
+++ b/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/task.md
@@ -6,7 +6,7 @@ An example of use:
 ```js
 let reg = /your regexp/g;
 
-let str = "1.5 0 12. 123.4.";
+let str = "1.5 0 -5 12. 123.4.";
 
-alert( str.match(reg) );   // 1.5, 0, 12, 123.4
+alert( str.match(reg) ); // 1.5, 12, 123.4 (ignores 0 and -5)
 ```
diff --git a/5-regular-expressions/09-regexp-groups/4-find-decimal-numbers/solution.md b/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/solution.md
similarity index 100%
rename from 5-regular-expressions/09-regexp-groups/4-find-decimal-numbers/solution.md
rename to 9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/solution.md
diff --git a/5-regular-expressions/09-regexp-groups/4-find-decimal-numbers/task.md b/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/task.md
similarity index 100%
rename from 5-regular-expressions/09-regexp-groups/4-find-decimal-numbers/task.md
rename to 9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/task.md
diff --git a/5-regular-expressions/09-regexp-groups/5-parse-expression/solution.md b/9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
similarity index 98%
rename from 5-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
rename to 9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
index 45c4ea2a0..3db5f667c 100644
--- a/5-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
+++ b/9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
@@ -41,7 +41,7 @@ function parse(expr) {
 
   let result = expr.match(reg);
 
-  if (!result) return;
+  if (!result) return [];
   result.shift();
 
   return result;
diff --git a/5-regular-expressions/09-regexp-groups/5-parse-expression/task.md b/9-regular-expressions/09-regexp-groups/5-parse-expression/task.md
similarity index 100%
rename from 5-regular-expressions/09-regexp-groups/5-parse-expression/task.md
rename to 9-regular-expressions/09-regexp-groups/5-parse-expression/task.md
diff --git a/5-regular-expressions/09-regexp-groups/article.md b/9-regular-expressions/09-regexp-groups/article.md
similarity index 55%
rename from 5-regular-expressions/09-regexp-groups/article.md
rename to 9-regular-expressions/09-regexp-groups/article.md
index 80721b71d..6b2a17f11 100644
--- a/5-regular-expressions/09-regexp-groups/article.md
+++ b/9-regular-expressions/09-regexp-groups/article.md
@@ -4,7 +4,7 @@ A part of a pattern can be enclosed in parentheses `pattern:(...)`. This is call
 
 That has two effects:
 
-1. It allows to place a part of the match into a separate array item when using  [String#match](mdn:js/String/match) or [RegExp#exec](mdn:/RegExp/exec) methods.
+1. It allows to place a part of the match into a separate array.
 2. If we put a quantifier after the parentheses, it applies to the parentheses as a whole, not the last character.
 
 ## Example
@@ -30,32 +30,30 @@ john.smith@site.com.uk
 
 The pattern: `pattern:[-.\w]+@([\w-]+\.)+[\w-]{2,20}`.
 
-- The first part before `@` may include any alphanumeric word characters, a dot and a dash `pattern:[-.\w]+`, like `match:john.smith`.
-- Then `pattern:@`
-- And then the domain and maybe a second-level domain like `site.com` or with subdomains like `host.site.com.uk`. We can match it as "a word followed by a dot" repeated one or more times for subdomains: `match:mail.` or `match:site.com.`, and then "a word" for the last part: `match:.com` or `match:.uk`.
+1. The first part `pattern:[-.\w]+` (before `@`) may include any alphanumeric word characters, a dot and a dash, to match `match:john.smith`.
+2. Then `pattern:@`, and the domain. It may be a subdomain like `host.site.com.uk`, so we match it as "a word followed by a dot `pattern:([\w-]+\.)` (repeated), and then the last part must be a word: `match:com` or `match:uk` (but not very long: 2-20 characters).
 
-    The word followed by a dot is `pattern:(\w+\.)+` (repeated). The last word should not have a dot at the end, so it's just `\w{2,20}`. The quantifier `pattern:{2,20}` limits the length, because domain zones are like `.uk` or `.com` or `.museum`, but can't be longer than 20 characters.
+That regexp is not perfect, but good enough to fix errors or occasional mistypes.
 
-    So the domain pattern is `pattern:(\w+\.)+\w{2,20}`. Now we replace `\w` with `[\w-]`, because dashes are also allowed in domains, and we get the final result.
-
-That regexp is not perfect, but usually works. It's short and good enough to fix errors or occasional mistypes.
-
-For instance, here we can find all emails in the string:
+For instance,  we can find all emails in the string:
 
 ```js run
 let reg = /[-.\w]+@([\w-]+\.)+[\w-]{2,20}/g;
 
-alert("my@mail.com @ his@site.com.uk".match(reg)); // my@mail.com,his@site.com.uk
+alert("my@mail.com @ his@site.com.uk".match(reg)); // my@mail.com, his@site.com.uk
 ```
 
+In this example parentheses were used to make a group for repeating `pattern:(...)+`. But there are other uses too, let's see them.
 
 ## Contents of parentheses  
 
 Parentheses are numbered from left to right. The search engine remembers the content of each and allows to reference it in the pattern or in the replacement string.
 
-For instance, we can find an HTML-tag using a (simplified) pattern `pattern:<.*?>`. Usually we'd want to do something with the result after it.
+For instance, we'd like to find HTML tags `pattern:<.*?>`, and process them.
+
+Let's wrap the inner content into parentheses, like this: `pattern:<(.*?)>`.
 
-If we enclose the inner contents of `<...>` into parentheses, then we can access it like this:
+We'll get them into an array:
 
 ```js run
 let str = '<h1>Hello, world!</h1>';
@@ -66,7 +64,7 @@ alert( str.match(reg) ); // Array: ["<h1>", "h1"]
 
 The call to [String#match](mdn:js/String/match) returns groups only if the regexp has no `pattern:/.../g` flag.
 
-If we need all matches with their groups then we can use [RegExp#exec](mdn:js/RegExp/exec) method as described in <info:regexp-methods>:
+If we need all matches with their groups then we can use `.matchAll` or `regexp.exec` as described in <info:regexp-methods>:
 
 ```js run
 let str = '<h1>Hello, world!</h1>';
@@ -74,13 +72,10 @@ let str = '<h1>Hello, world!</h1>';
 // two matches: opening <h1> and closing </h1> tags
 let reg = /<(.*?)>/g;
 
-let match;
+let matches = Array.from( str.matchAll(reg) );
 
-while (match = reg.exec(str)) {
-  // first shows the match: <h1>,h1
-  // then shows the match: </h1>,/h1
-  alert(match);
-}
+alert(matches[0]); //  Array: ["<h1>", "h1"]
+alert(matches[1]); //  Array: ["</h1>", "/h1"]
 ```
 
 Here we have two matches for `pattern:<(.*?)>`, each of them is an array with the full match and groups.
@@ -146,13 +141,78 @@ alert( match[2] ); // c
 
 The array length is permanent: `3`. But there's nothing for the group `pattern:(z)?`, so the result is `["ac", undefined, "c"]`.
 
+## Named groups
+
+Remembering groups by their numbers is hard. For simple patterns it's doable, but for more complex ones we can give names to parentheses.
+
+That's done by putting `pattern:?<name>` immediately after the opening paren, like this:
+
+```js run
+*!*
+let dateRegexp = /(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})/;
+*/!*
+let str = "2019-04-30";
+
+let groups = str.match(dateRegexp).groups;
+
+alert(groups.year); // 2019
+alert(groups.month); // 04
+alert(groups.day); // 30
+```
+
+As you can see, the groups reside in the `.groups` property of the match.
+
+We can also use them in replacements, as `pattern:$<name>` (like `$1..9`, but name instead of a digit).
+
+For instance, let's rearrange the date into `day.month.year`:
+
+```js run
+let dateRegexp = /(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})/;
+
+let str = "2019-04-30";
+
+let rearranged = str.replace(dateRegexp, '$<day>.$<month>.$<year>');
+
+alert(rearranged); // 30.04.2019
+```
+
+If we use a function, then named `groups` object is always the last argument:
+
+```js run
+let dateRegexp = /(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})/;
+
+let str = "2019-04-30";
+
+let rearranged = str.replace(dateRegexp,
+  (str, year, month, day, offset, input, groups) =>
+   `${groups.day}.${groups.month}.${groups.year}`
+);
+
+alert(rearranged); // 30.04.2019
+```
+
+Usually, when we intend to use named groups, we don't need positional arguments of the function. For the majority of real-life cases we only need `str` and `groups`.
+
+So we can write it a little bit shorter:
+
+```js
+let rearranged = str.replace(dateRegexp, (str, ...args) => {
+  let {year, month, day} = args.pop();
+  alert(str); // 2019-04-30
+  alert(year); // 2019
+  alert(month); // 04
+  alert(day); // 30
+});
+```
+
+
 ## Non-capturing groups with ?:
 
-Sometimes we need parentheses to correctly apply a quantifier, but we don't want their contents in the array.
+Sometimes we need parentheses to correctly apply a quantifier, but we don't want the contents in results.
 
 A group may be excluded by adding `pattern:?:` in the beginning.
 
-For instance, if we want to find `pattern:(go)+`, but don't want to put remember the contents (`go`) in a separate array item, we can write: `pattern:(?:go)+`.
+For instance, if we want to find `pattern:(go)+`, but don't want to remember the contents (`go`) in a separate array item, we can write: `pattern:(?:go)+`.
 
 In the example below we only get the name "John" as a separate member of the `results` array:
 
@@ -168,3 +228,10 @@ let result = str.match(reg);
 alert( result.length ); // 2
 alert( result[1] ); // John
 ```
+
+## Summary
+
+- Parentheses can be:
+  - capturing `(...)`, ordered left-to-right, accessible by number.
+  - named capturing `(?<name>...)`, accessible by name.
+  - non-capturing `(?:...)`, used only to apply quantifier to the whole groups.
diff --git a/9-regular-expressions/09-regexp-groups/regexp-nested-groups.png b/9-regular-expressions/09-regexp-groups/regexp-nested-groups.png
new file mode 100644
index 000000000..4949237a3
Binary files /dev/null and b/9-regular-expressions/09-regexp-groups/regexp-nested-groups.png differ
diff --git a/9-regular-expressions/09-regexp-groups/regexp-nested-groups@2x.png b/9-regular-expressions/09-regexp-groups/regexp-nested-groups@2x.png
new file mode 100644
index 000000000..6dcdfe406
Binary files /dev/null and b/9-regular-expressions/09-regexp-groups/regexp-nested-groups@2x.png differ
diff --git a/9-regular-expressions/10-regexp-backreferences/article.md b/9-regular-expressions/10-regexp-backreferences/article.md
new file mode 100644
index 000000000..a7a934e4a
--- /dev/null
+++ b/9-regular-expressions/10-regexp-backreferences/article.md
@@ -0,0 +1,65 @@
+# Backreferences in pattern: \n and \k
+
+Capturing groups can be accessed not only in the result or in the replacement string, but also in the pattern itself.
+
+## Backreference by number: \n
+
+A group can be referenced in the pattern using `\n`, where `n` is the group number.
+
+To make things clear let's consider a task.
+
+We need to find a quoted string: either a single-quoted `subject:'...'` or a double-quoted `subject:"..."` -- both variants need to match.
+
+How to look for them?
+
+We can put two kinds of quotes in the pattern: `pattern:['"](.*?)['"]`, but it would find strings with mixed quotes, like `match:"...'` and `match:'..."`. That would lead to incorrect matches when one quote appears inside other ones, like the string `subject:"She's the one!"`:
+
+```js run
+let str = `He said: "She's the one!".`;
+
+let reg = /['"](.*?)['"]/g;
+
+// The result is not what we expect
+alert( str.match(reg) ); // "She'
+```
+
+As we can see, the pattern found an opening quote `match:"`, then the text is consumed lazily till the other quote `match:'`, that closes the match.
+
+To make sure that the pattern looks for the closing quote exactly the same as the opening one, we can make a groups of it and use the backreference.
+
+Here's the correct code:
+
+```js run
+let str = `He said: "She's the one!".`;
+
+*!*
+let reg = /(['"])(.*?)\1/g;
+*/!*
+
+alert( str.match(reg) ); // "She's the one!"
+```
+
+Now it works! The regular expression engine finds the first quote `pattern:(['"])` and remembers the content of `pattern:(...)`, that's the first capturing group.
+
+Further in the pattern `pattern:\1` means "find the same text as in the first group", exactly the same quote in our case.
+
+Please note:
+
+- To reference a group inside a replacement string -- we use `$1`, while in the pattern -- a backslash `\1`.
+- If we use `?:` in the group, then we can't reference it. Groups that are excluded from capturing `(?:...)` are not remembered by the engine.
+
+## Backreference by name: `\k<name>`
+
+For named groups, we can backreference by `\k<name>`.
+
+The same example with the named group:
+
+```js run
+let str = `He said: "She's the one!".`;
+
+*!*
+let reg = /(?<quote>['"])(.*?)\k<quote>/g;
+*/!*
+
+alert( str.match(reg) ); // "She's the one!"
+```
diff --git a/5-regular-expressions/11-regexp-alternation/01-find-programming-language/solution.md b/9-regular-expressions/11-regexp-alternation/01-find-programming-language/solution.md
similarity index 100%
rename from 5-regular-expressions/11-regexp-alternation/01-find-programming-language/solution.md
rename to 9-regular-expressions/11-regexp-alternation/01-find-programming-language/solution.md
diff --git a/5-regular-expressions/11-regexp-alternation/01-find-programming-language/task.md b/9-regular-expressions/11-regexp-alternation/01-find-programming-language/task.md
similarity index 100%
rename from 5-regular-expressions/11-regexp-alternation/01-find-programming-language/task.md
rename to 9-regular-expressions/11-regexp-alternation/01-find-programming-language/task.md
diff --git a/5-regular-expressions/11-regexp-alternation/02-find-matching-bbtags/solution.md b/9-regular-expressions/11-regexp-alternation/02-find-matching-bbtags/solution.md
similarity index 100%
rename from 5-regular-expressions/11-regexp-alternation/02-find-matching-bbtags/solution.md
rename to 9-regular-expressions/11-regexp-alternation/02-find-matching-bbtags/solution.md
diff --git a/5-regular-expressions/11-regexp-alternation/02-find-matching-bbtags/task.md b/9-regular-expressions/11-regexp-alternation/02-find-matching-bbtags/task.md
similarity index 100%
rename from 5-regular-expressions/11-regexp-alternation/02-find-matching-bbtags/task.md
rename to 9-regular-expressions/11-regexp-alternation/02-find-matching-bbtags/task.md
diff --git a/5-regular-expressions/11-regexp-alternation/03-match-quoted-string/solution.md b/9-regular-expressions/11-regexp-alternation/03-match-quoted-string/solution.md
similarity index 100%
rename from 5-regular-expressions/11-regexp-alternation/03-match-quoted-string/solution.md
rename to 9-regular-expressions/11-regexp-alternation/03-match-quoted-string/solution.md
diff --git a/5-regular-expressions/11-regexp-alternation/03-match-quoted-string/task.md b/9-regular-expressions/11-regexp-alternation/03-match-quoted-string/task.md
similarity index 100%
rename from 5-regular-expressions/11-regexp-alternation/03-match-quoted-string/task.md
rename to 9-regular-expressions/11-regexp-alternation/03-match-quoted-string/task.md
diff --git a/5-regular-expressions/11-regexp-alternation/04-match-exact-tag/solution.md b/9-regular-expressions/11-regexp-alternation/04-match-exact-tag/solution.md
similarity index 100%
rename from 5-regular-expressions/11-regexp-alternation/04-match-exact-tag/solution.md
rename to 9-regular-expressions/11-regexp-alternation/04-match-exact-tag/solution.md
diff --git a/5-regular-expressions/11-regexp-alternation/04-match-exact-tag/task.md b/9-regular-expressions/11-regexp-alternation/04-match-exact-tag/task.md
similarity index 100%
rename from 5-regular-expressions/11-regexp-alternation/04-match-exact-tag/task.md
rename to 9-regular-expressions/11-regexp-alternation/04-match-exact-tag/task.md
diff --git a/5-regular-expressions/11-regexp-alternation/article.md b/9-regular-expressions/11-regexp-alternation/article.md
similarity index 59%
rename from 5-regular-expressions/11-regexp-alternation/article.md
rename to 9-regular-expressions/11-regexp-alternation/article.md
index a01eac0f1..0caa6de02 100644
--- a/5-regular-expressions/11-regexp-alternation/article.md
+++ b/9-regular-expressions/11-regexp-alternation/article.md
@@ -20,46 +20,35 @@ alert( str.match(reg) ); // 'HTML', 'CSS', 'JavaScript'
 
 We already know a similar thing -- square brackets. They allow to choose between multiple character, for instance `pattern:gr[ae]y` matches `match:gray` or `match:grey`.
 
-Alternation works not on a character level, but on expression level. A regexp `pattern:A|B|C` means one of expressions `A`, `B` or `C`.
+Square brackets allow only characters or character sets. Alternation allows any expressions. A regexp `pattern:A|B|C` means one of expressions `A`, `B` or `C`.
 
 For instance:
 
 - `pattern:gr(a|e)y` means exactly the same as `pattern:gr[ae]y`.
-- `pattern:gra|ey` means "gra" or "ey".
+- `pattern:gra|ey` means `match:gra` or `match:ey`.
 
 To separate a part of the pattern for alternation we usually enclose it in parentheses, like this: `pattern:before(XXX|YYY)after`.
 
 ## Regexp for time
 
-In previous chapters there was a task to build a regexp for searching time in the form `hh:mm`, for instance `12:00`. But a simple `pattern:\d\d:\d\d` is too vague. It accepts `25:99` as the time.
+In previous chapters there was a task to build a regexp for searching time in the form `hh:mm`, for instance `12:00`. But a simple `pattern:\d\d:\d\d` is too vague. It accepts `25:99` as the time (99 seconds is valid, but shouldn't be).
 
 How can we make a better one?
 
-We can apply more careful matching:
+We can apply more careful matching. First, the hours:
 
-- The first digit must be `0` or `1` followed by any digit.
-- Or `2` followed by `pattern:[0-3]`
+- If the first digit is `0` or `1`, then the next digit can by anything.
+- Or, if the first digit is `2`, then the next must be `pattern:[0-3]`.
 
 As a regexp: `pattern:[01]\d|2[0-3]`.
 
-Then we can add a colon and the minutes part.
-
-The minutes must be from `0` to `59`, in the regexp language that means the first digit  `pattern:[0-5]` followed by any other digit `\d`.
+Next, the minutes must be from `0` to `59`. In the regexp language that means `pattern:[0-5]\d`: the first digit `0-5`, and then any digit.
 
 Let's glue them together into the pattern: `pattern:[01]\d|2[0-3]:[0-5]\d`.
 
-We're almost done, but there's a problem. The alternation `|` is between the `pattern:[01]\d` and `pattern:2[0-3]:[0-5]\d`. That's wrong, because it will match either the left or the right pattern:
-
-
-```js run
-let reg = /[01]\d|2[0-3]:[0-5]\d/g;
-
-alert("12".match(reg)); // 12 (matched [01]\d)
-```
-
-That's rather obvious, but still an often mistake when starting to work with regular expressions.
+We're almost done, but there's a problem. The alternation `pattern:|` now happens to be between `pattern:[01]\d` and `pattern:2[0-3]:[0-5]\d`.
 
-We need to add parentheses to apply alternation exactly to hours: `[01]\d` OR `2[0-3]`.
+That's wrong, as it should be applied only to hours `[01]\d` OR `2[0-3]`. That's a common mistake when starting to work with regular expressions.
 
 The correct variant:
 
diff --git a/5-regular-expressions/12-regexp-anchors/1-start-end/solution.md b/9-regular-expressions/12-regexp-anchors/1-start-end/solution.md
similarity index 100%
rename from 5-regular-expressions/12-regexp-anchors/1-start-end/solution.md
rename to 9-regular-expressions/12-regexp-anchors/1-start-end/solution.md
diff --git a/5-regular-expressions/12-regexp-anchors/1-start-end/task.md b/9-regular-expressions/12-regexp-anchors/1-start-end/task.md
similarity index 100%
rename from 5-regular-expressions/12-regexp-anchors/1-start-end/task.md
rename to 9-regular-expressions/12-regexp-anchors/1-start-end/task.md
diff --git a/5-regular-expressions/12-regexp-anchors/2-test-mac/solution.md b/9-regular-expressions/12-regexp-anchors/2-test-mac/solution.md
similarity index 100%
rename from 5-regular-expressions/12-regexp-anchors/2-test-mac/solution.md
rename to 9-regular-expressions/12-regexp-anchors/2-test-mac/solution.md
diff --git a/5-regular-expressions/12-regexp-anchors/2-test-mac/task.md b/9-regular-expressions/12-regexp-anchors/2-test-mac/task.md
similarity index 100%
rename from 5-regular-expressions/12-regexp-anchors/2-test-mac/task.md
rename to 9-regular-expressions/12-regexp-anchors/2-test-mac/task.md
diff --git a/5-regular-expressions/12-regexp-anchors/article.md b/9-regular-expressions/12-regexp-anchors/article.md
similarity index 97%
rename from 5-regular-expressions/12-regexp-anchors/article.md
rename to 9-regular-expressions/12-regexp-anchors/article.md
index b4981e094..0c2dd578a 100644
--- a/5-regular-expressions/12-regexp-anchors/article.md
+++ b/9-regular-expressions/12-regexp-anchors/article.md
@@ -18,7 +18,7 @@ The pattern `pattern:^Mary` means: "the string start and then Mary".
 
 Now let's test whether the text ends with an email.
 
-To match an email, we can use a regexp `pattern:[-.\w]+@([\w-]+\.)+[\w-]{2,20}`. It's not perfect, but mostly works.
+To match an email, we can use a regexp `pattern:[-.\w]+@([\w-]+\.)+[\w-]{2,20}`.
 
 To test whether the string ends with the email, let's add `pattern:$` to the pattern:
 
diff --git a/5-regular-expressions/13-regexp-multiline-mode/article.md b/9-regular-expressions/13-regexp-multiline-mode/article.md
similarity index 100%
rename from 5-regular-expressions/13-regexp-multiline-mode/article.md
rename to 9-regular-expressions/13-regexp-multiline-mode/article.md
diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
new file mode 100644
index 000000000..376d52d66
--- /dev/null
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -0,0 +1,105 @@
+# Lookahead and lookbehind
+
+Sometimes we need to match a pattern only if followed by another pattern. For instance, we'd like to get the price from a string like `subject:1 turkey costs 30€`.
+
+We need a number (let's say a price has no decimal point) followed by `subject:€` sign.
+
+That's what lookahead is for.
+
+## Lookahead
+
+The syntax is: `pattern:x(?=y)`, it means "look for `pattern:x`, but match only if followed by `pattern:y`".
+
+For an integer amount followed by `subject:€`, the regexp will be `pattern:\d+(?=€)`:
+
+```js run
+let str = "1 turkey costs 30€";
+
+alert( str.match(/\d+(?=€)/) ); // 30 (correctly skipped the sole number 1)
+```
+
+Let's say we want a quantity instead, that is a number, NOT followed by `subject:€`.
+
+Here a negative lookahead can be applied.
+
+The syntax is: `pattern:x(?!y)`, it means "search `pattern:x`, but only if not followed by `pattern:y`".
+
+```js run
+let str = "2 turkeys cost 60€";
+
+alert( str.match(/\d+(?!€)/) ); // 2 (correctly skipped the price)
+```
+
+## Lookbehind
+
+Lookahead allows to add a condition for "what goes after".
+
+Lookbehind is similar, but it looks behind. That is, it allows to match a pattern only if there's something before.
+
+The syntax is:
+- Positive lookbehind: `pattern:(?<=y)x`, matches `pattern:x`, but only if it follows after `pattern:y`.
+- Negative lookbehind: `pattern:(?<!y)x`, matches `pattern:x`, but only if there's no `pattern:y` before.
+
+For example, let's change the price to US dollars. The dollar sign is usually before the number, so to look for `$30` we'll use `pattern:(?<=\$)\d+` -- an amount preceeded by `subject:$`:
+
+```js run
+let str = "1 turkey costs $30";
+
+alert( str.match(/(?<=\$)\d+/) ); // 30 (skipped the sole number)
+```
+
+And, to find the quantity -- a number, not preceeded by `subject:$`, we can use a negative lookbehind `pattern:(?<!\$)\d+`:
+
+```js run
+let str = "2 turkeys cost $60";
+
+alert( str.match(/(?<!\$)\d+/) ); // 2 (skipped the price)
+```
+
+## Capture groups
+
+Generally, what's inside the lookaround (a common name for both lookahead and lookbehind) parentheses does not become a part of the match.
+
+E.g. in the pattern `pattern:\d+(?!€)`, the `pattern:€` sign doesn't get captured as a part of the match.
+
+But if we want to capture the whole lookaround expression or a part of it, that's possible. Just need to wrap that into additional parentheses.
+
+For instance, here the currency `pattern:(€|kr)` is captured, along with the amount:
+
+```js run
+let str = "1 turkey costs 30€";
+let reg = /\d+(?=(€|kr))/; // extra parentheses around €|kr
+
+alert( str.match(reg) ); // 30, €
+```
+
+And here's the same for lookbehind:
+
+```js run
+let str = "1 turkey costs $30";
+let reg = /(?<=(\$|£))\d+/;
+
+alert( str.match(reg) ); // 30, $
+```
+
+Please note that for lookbehind the order stays be same, even though lookahead parentheses are before the main pattern.
+
+Usually parentheses are numbered left-to-right, but lookbehind is an exception, it is always captured after the main pattern. So the match for `pattern:\d+` goes in the result first, and then for `pattern:(\$|£)`.
+
+
+## Summary
+
+Lookahead and lookbehind (commonly referred to as "lookaround") are useful for simple regular expressions, when we'd like not to take something into the match depending on the context before/after it.
+
+Sometimes we can do the same manually, that is: match all and filter by context in the loop. Remember, `str.matchAll` and `reg.exec` return matches with `.index` property, so we know where exactly in the text it is. But generally regular expressions can do it better.
+
+Lookaround types:
+
+| Pattern            | type             | matches |
+|--------------------|------------------|---------|
+| `pattern:x(?=y)`   | Positive lookahead | `x` if followed by `y` |
+| `pattern:x(?!y)`   | Negative lookahead | `x` if not followed by `y` |
+| `pattern:(?<=y)x` |  Positive lookbehind | `x` if after `y` |
+| `pattern:(?<!y)x` | Negative lookbehind | `x` if not after `y` |
+
+Lookahead can also used to disable backtracking. Why that may be needed -- see in the next chapter.
diff --git a/5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md b/9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
similarity index 56%
rename from 5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
rename to 9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
index cdb5f40e5..54bbccd9b 100644
--- a/5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+++ b/9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
@@ -6,11 +6,13 @@ Sooner or later most developers occasionally face such behavior.
 
 The typical situation -- a regular expression works fine sometimes, but for certain strings it "hangs"  consuming 100% of CPU.
 
-That may even be a vulnerability. For instance, if JavaScript is on the server, and it uses regular expressions to process user data, then such an input may cause denial of service. The author personally saw and reported such vulnerabilities even for well-known and widely used programs.
+In a web-browser it kills the page. Not a good thing for sure.
+
+For server-side JavaScript it may become a vulnerability, and it uses regular expressions to process user data. Bad input will make the process hang, causing denial of service. The author personally saw and reported such vulnerabilities even for very well-known and widely used programs.
 
 So the problem is definitely worth to deal with.
 
-## Example
+## Introduction
 
 The plan will be like this:
 
@@ -24,66 +26,67 @@ We want to find all tags, with or without attributes -- like `subject:<a href=".
 
 In particular, we need it to match tags like `<a test="<>" href="#">` -- with `<` and `>` in attributes. That's allowed by [HTML standard](https://html.spec.whatwg.org/multipage/syntax.html#syntax-attributes).
 
-Now we can see that a simple regexp like `pattern:<[^>]+>` doesn't work, because it stops at the first `>`, and we need to ignore `<>` inside an attribute.
+Now we can see that a simple regexp like `pattern:<[^>]+>` doesn't work, because it stops at the first `>`, and we need to ignore `<>` if inside an attribute.
 
 ```js run
 // the match doesn't reach the end of the tag - wrong!
 alert( '<a test="<>" href="#">'.match(/<[^>]+>/) ); // <a test="<>
 ```
 
-We need the whole tag.
-
 To correctly handle such situations we need a more complex regular expression. It will have the form  `pattern:<tag (key=value)*>`.
 
-In the regexp language that is: `pattern:<\w+(\s*\w+=(\w+|"[^"]*")\s*)*>`:
+1. For the `tag` name: `pattern:\w+`,
+2. For the `key` name: `pattern:\w+`,
+3. And the `value`: a quoted string `pattern:"[^"]*"`.
 
-1. `pattern:<\w+` -- is the tag start,
-2. `pattern:(\s*\w+=(\w+|"[^"]*")\s*)*` -- is an arbitrary number of pairs `word=value`, where the value can be either a word `pattern:\w+` or a quoted string `pattern:"[^"]*"`.
+If we substitute these into the pattern above and throw in some optional spaces `pattern:\s`, the full regexp becomes: `pattern:<\w+(\s*\w+="[^"]*"\s*)*>`.
 
-That doesn't yet support few details of HTML grammar, for instance strings in 'single' quotes, but they can be added later, so that's somewhat close to real life. For now we want the regexp to be simple.
+That regexp is not perfect! It doesn't yet support all details of HTML, for instance unquoted values, and there are other ways to improve, but let's not add complexity. It will demonstrate the problem for us.
 
-Let's try it in action:
+The regexp seems to work:
 
 ```js run
-let reg = /<\w+(\s*\w+=(\w+|"[^"]*")\s*)*>/g;
+let reg = /<\w+(\s*\w+="[^"]*"\s*)*>/g;
 
 let str='...<a test="<>" href="#">... <b>...';
 
 alert( str.match(reg) ); // <a test="<>" href="#">, <b>
 ```
 
-Great, it works! It found both the long tag `match:<a test="<>" href="#">` and the short one `match:<b>`.
+Great! It found both the long tag `match:<a test="<>" href="#">` and the short one `match:<b>`.
+
+Now, that we've got a seemingly working solution, let's get to the infinite backtracking itself.
 
-Now let's see the problem.
+## Infinite backtracking
 
-If you run the example below, it may hang the browser (or whatever JavaScript engine runs):
+If you run our regexp on the input below, it may hang the browser (or another JavaScript host):
 
 ```js run
-let reg = /<\w+(\s*\w+=(\w+|"[^"]*")\s*)*>/g;
+let reg = /<\w+(\s*\w+="[^"]*"\s*)*>/g;
 
-let str = `<tag a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  
-  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b`;
+let str = `<tag a="b"  a="b"  a="b"  a="b"  a="b"  a="b"  a="b"  a="b"
+  a="b"  a="b"  a="b"  a="b"  a="b"  a="b"  a="b"  a="b"  a="b" a="b"  a="b"  a="b"  a="b"`;
 
 *!*
-// The search will take a long long time
+// The search will take a long, long time
 alert( str.match(reg) );
 */!*
 ```
 
-Some regexp engines can handle that search, but most of them don't.
+Some regexp engines can handle that search, but most of them can't.
 
-What's the matter? Why a simple regular expression on such a small string "hangs"?
+What's the matter? Why a simple regular expression "hangs" on such a small string?
 
-Let's simplify the situation by removing the tag and quoted strings.
+Let's simplify the regexp by stripping the tag name and the quotes. So that we look only for `key=value` attributes: `pattern:<(\s*\w+=\w+\s*)*>`.
 
-Here we look only for attributes:
+Unfortunately, the regexp still hangs:
 
 ```js run
 // only search for space-delimited attributes
 let reg = /<(\s*\w+=\w+\s*)*>/g;
 
 let str = `<a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b
-  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b`;
+  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b`;
 
 *!*
 // the search will take a long, long time
@@ -91,11 +94,9 @@ alert( str.match(reg) );
 */!*
 ```
 
-The same problem persists.
+Here we end the demo of the problem and start looking into what's going on, why it hangs and how to fix it.
 
-Here we end the demo of the problem and start looking into what's going on and why it hangs.
-
-## Backtracking
+## Detailed example
 
 To make an example even simpler, let's consider `pattern:(\d+)*$`.
 
@@ -109,7 +110,7 @@ So what's wrong with the regexp?
 
 First, one may notice that the regexp is a little bit strange. The quantifier `pattern:*` looks extraneous. If we want a number, we can use `pattern:\d+$`.
 
-Indeed, the regexp is artificial. But the reason why it is slow is the same as those we saw above. So let's understand it, and then return to the real-life examples.
+Indeed, the regexp is artificial. But the reason why it is slow is the same as those we saw above. So let's understand it, and then the previous example will become obvious.
 
 What happen during the search of `pattern:(\d+)*$` in the line `subject:123456789z`?
 
@@ -119,9 +120,9 @@ What happen during the search of `pattern:(\d+)*$` in the line `subject:12345678
     \d+.......
     (123456789)z
     ```
-2. Then it tries to apply the star around the parentheses `pattern:(\d+)*`, but there are no more digits, so it the star doesn't give anything.
+2. Then it tries to apply the star quantifier, but there are no more digits, so it the star doesn't give anything.
 
-    Then the pattern has the string end anchor `pattern:$`, and in the text we have `subject:z`.
+3. Then the pattern expects to see the string end `pattern:$`, and in the text we have `subject:z`, so there's no match:
 
     ```
                X
@@ -129,17 +130,16 @@ What happen during the search of `pattern:(\d+)*$` in the line `subject:12345678
     (123456789)z
     ```
 
-    No match!
-3. There's no match, so the greedy quantifier `pattern:+` decreases the count of repetitions (backtracks).
+4. As there's no match, the greedy quantifier `pattern:+` decreases the count of repetitions (backtracks).
 
-    Now `\d+` is not all digits, but all except the last one:
+    Now `\d+` doesn't take all digits, but all except the last one:
     ```
     \d+.......
     (12345678)9z
     ```
-4. Now the engine tries to continue the search from the new position (`9`).
+5. Now the engine tries to continue the search from the new position (`9`).
 
-    The start `pattern:(\d+)*` can now be applied -- it gives the number `match:9`:
+    The star `pattern:(\d+)*` can be applied -- it gives the number `match:9`:
 
     ```
 
@@ -155,8 +155,8 @@ What happen during the search of `pattern:(\d+)*$` in the line `subject:12345678
     (12345678)(9)z
     ```
 
-    There's no match, so the engine will continue backtracking.
-5. Now the first number `pattern:\d+` will have 7 digits, and the rest of the string `subject:89` becomes the second `pattern:\d+`:
+
+5. There's no match, so the engine will continue backtracking, decreasing the number of repetitions for `pattern:\d+` down to 7 digits. So the rest of the string `subject:89` becomes the second `pattern:\d+`:
 
     ```
                  X
@@ -192,38 +192,41 @@ What happen during the search of `pattern:(\d+)*$` in the line `subject:12345678
 
 The regular expression engine goes through all combinations of `123456789` and their subsequences. There are a lot of them, that's why it takes so long.
 
-A smart guy can say here: "Backtracking? Let's turn on the lazy mode -- and no more backtracking!".
+What to do?
+
+Should we turn on the lazy mode?
 
-Let's replace `pattern:\d+` with `pattern:\d+?` and see if it works (careful, can hang the browser)
+Unfortunately, it doesn't: if we replace `pattern:\d+` with `pattern:\d+?`, that still hangs:
 
 ```js run
 // sloooooowwwwww
 alert( '12345678901234567890123456789123456789z'.match(/(\d+?)*$/) );
 ```
 
-No, it doesn't.
+Lazy quantifiers actually do the same, but in the reverse order.
 
-Lazy quantifiers actually do the same, but in the reverse order. Just think about how the search engine would work in this case.
+Just think about how the search engine would work in this case.
 
 Some regular expression engines have tricky built-in checks to detect infinite backtracking or other means to work around them, but there's no universal solution.
 
+## Back to tags
+
 In the example above, when we search `pattern:<(\s*\w+=\w+\s*)*>` in the string `subject:<a=b  a=b  a=b  a=b` -- the similar thing happens.
 
-The string has no `>` at the end, so the match is impossible, but the regexp engine does not know about it. The search backtracks trying different combinations of `pattern:(\s*\w+=\w+\s*)`:
+The string has no `>` at the end, so the match is impossible, but the regexp engine doesn't know about it. The search backtracks trying different combinations of `pattern:(\s*\w+=\w+\s*)`:
 
 ```
 (a=b a=b a=b) (a=b)
 (a=b a=b) (a=b a=b)
+(a=b) (a=b a=b a=b)
 ...
 ```
 
 ## How to fix?
 
-The problem -- too many variants in backtracking even if we don't need them.
-
-For instance, in the pattern `pattern:(\d+)*$` we (people) can easily see that `pattern:(\d+)` does not need to backtrack.
+The backtracking checks many variants that are an obvious fail for a human.
 
-Decreasing the count of `pattern:\d+` can not help to find a match, there's no matter between these two:
+For instance, in the pattern `pattern:(\d+)*$` a human can easily see that `pattern:(\d+)*` does not need to backtrack `pattern:+`. There's no difference between one or two `\d+`:
 
 ```
 \d+........
@@ -233,40 +236,58 @@ Decreasing the count of `pattern:\d+` can not help to find a match, there's no m
 (1234)(56789)z
 ```
 
-Let's get back to more real-life example: `pattern:<(\s*\w+=\w+\s*)*>`. We want it to find pairs `name=value` (as many as it can). There's no need in backtracking here.
+Let's get back to more real-life example: `pattern:<(\s*\w+=\w+\s*)*>`. We want it to find pairs `name=value` (as many as it can).
 
-In other words, if it found many `name=value` pairs and then can't find `>`, then there's no need to decrease the count of repetitions. Even if we match one pair less, it won't give us the closing `>`:
+What we would like to do is to forbid backtracking.
+
+There's totally no need to decrease the number of repetitions.
+
+In other words, if it found three `name=value` pairs and then can't find `>` after them, then there's no need to decrease the count of repetitions. There are definitely no `>` after those two (we backtracked one `name=value` pair, it's there):
+
+```
+(name=value) name=value
+```
 
 Modern regexp engines support so-called "possessive" quantifiers for that. They are like greedy, but don't backtrack at all. Pretty simple, they capture whatever they can, and the search continues. There's also another tool called "atomic groups" that forbid backtracking inside parentheses.
 
 Unfortunately, but both these features are not supported by JavaScript.
 
-Although we can get a similar affect using lookahead. There's more about the relation between possessive quantifiers and lookahead in articles [Regex: Emulate Atomic Grouping (and Possessive Quantifiers) with LookAhead](http://instanceof.me/post/52245507631/regex-emulate-atomic-grouping-with-lookahead) and [Mimicking Atomic Groups](http://blog.stevenlevithan.com/archives/mimic-atomic-groups).
+### Lookahead to the rescue
+
+We can forbid backtracking using lookahead.
 
 The pattern to take as much repetitions as possible without backtracking is: `pattern:(?=(a+))\1`.
 
-In other words, the lookahead `pattern:?=` looks for the maximal count `pattern:a+` from the current position. And then they are "consumed into the result" by the backreference `pattern:\1`.
+In other words:
+- The lookahead `pattern:?=` looks for the maximal count `pattern:a+` from the current position.
+- And then they are "consumed into the result" by the backreference `pattern:\1` (`pattern:\1` corresponds to the content of the second parentheses, that is `pattern:a+`).
 
 There will be no backtracking, because lookahead does not backtrack. If it found like 5 times of `pattern:a+` and the further match failed, then it doesn't go back to 4.
 
+```smart
+There's more about the relation between possessive quantifiers and lookahead in articles [Regex: Emulate Atomic Grouping (and Possessive Quantifiers) with LookAhead](http://instanceof.me/post/52245507631/regex-emulate-atomic-grouping-with-lookahead) and [Mimicking Atomic Groups](http://blog.stevenlevithan.com/archives/mimic-atomic-groups).
+```
+
+So this trick makes the problem disappear.
+
 Let's fix the regexp for a tag with attributes from the beginning of the chapter`pattern:<\w+(\s*\w+=(\w+|"[^"]*")\s*)*>`. We'll use lookahead to prevent backtracking of `name=value` pairs:
 
 ```js run
 // regexp to search name=value
 let attrReg = /(\s*\w+=(\w+|"[^"]*")\s*)/
 
-// use it inside the regexp for tag
-let reg = new RegExp('<\\w+(?=(' + attrReg.source + '*))\\1>', 'g');
+// use new RegExp to nicely insert its source into (?=(a+))\1
+let fixedReg = new RegExp(`<\\w+(?=(${attrReg.source}*))\\1>`, 'g');
 
-let good = '...<a test="<>" href="#">... <b>...';
+let goodInput = '...<a test="<>" href="#">... <b>...';
 
-let bad = `<tag a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b
+let badInput = `<tag a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b
   a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b  a=b`;
 
-alert( good.match(reg) ); // <a test="<>" href="#">, <b>
-alert( bad.match(reg) ); // null (no results, fast!)
+alert( goodInput.match(fixedReg) ); // <a test="<>" href="#">, <b>
+alert( badInput.match(fixedReg) ); // null (no results, fast!)
 ```
 
-Great, it works! We found a long tag  `match:<a test="<>" href="#">` and a small one `match:<b>` and didn't hang the engine.
+Great, it works! We found both a long tag  `match:<a test="<>" href="#">` and a small one `match:<b>`, and (!) didn't hang the engine on the bad input.
 
 Please note the `attrReg.source` property. `RegExp` objects provide access to their source string in it. That's convenient when we want to insert one regexp into another.
diff --git a/5-regular-expressions/06-regexp-unicode/article.md b/9-regular-expressions/20-regexp-unicode/article.md
similarity index 54%
rename from 5-regular-expressions/06-regexp-unicode/article.md
rename to 9-regular-expressions/20-regexp-unicode/article.md
index 0cac00138..68eebca8b 100644
--- a/5-regular-expressions/06-regexp-unicode/article.md
+++ b/9-regular-expressions/20-regexp-unicode/article.md
@@ -1,5 +1,5 @@
 
-# The unicode flag
+# Unicode: flag "u"
 
 The unicode flag `/.../u` enables the correct support of surrogate pairs.
 
@@ -37,33 +37,53 @@ Normally, regular expressions also treat "long characters" as two 2-byte ones.
 That leads to odd results, for instance let's try to find `pattern:[𝒳𝒴]` in the string `subject:𝒳`:
 
 ```js run
-alert( '𝒳'.match(/[𝒳𝒴]/) ); // odd result
+alert( '𝒳'.match(/[𝒳𝒴]/) ); // odd result (wrong match actually, "half-character")
 ```
 
-The result would be wrong, because by default the regexp engine does not understand surrogate pairs. It thinks that `[𝒳𝒴]` are not two, but four characters: the left half of `𝒳` `(1)`, the right half of `𝒳` `(2)`, the left half of `𝒴` `(3)`, the right half of `𝒴` `(4)`.
+The result is wrong, because by default the regexp engine does not understand surrogate pairs.
 
-So it finds the left half of `𝒳` in the string `𝒳`, not the whole symbol.
+So, it thinks that `[𝒳𝒴]` are not two, but four characters:
+1. the left half of `𝒳` `(1)`,
+2. the right half of `𝒳` `(2)`,
+3. the left half of `𝒴` `(3)`,
+4. the right half of `𝒴` `(4)`.
 
-In other words, the search works like `'12'.match(/[1234]/)` -- the `1` is returned (left half of `𝒳`).
+We can list them like this:
 
-The `/.../u` flag fixes that. It enables surrogate pairs in the regexp engine, so the result is correct:
+```js run
+for(let i=0; i<'𝒳𝒴'.length; i++) {
+  alert('𝒳𝒴'.charCodeAt(i)); // 55349, 56499, 55349, 56500
+};
+```
+
+So it finds only the "left half" of `𝒳`.
+
+In other words, the search works like `'12'.match(/[1234]/)`: only `1` is returned.
+
+## The "u" flag
+
+The `/.../u` flag fixes that.
+
+It enables surrogate pairs in the regexp engine, so the result is correct:
 
 ```js run
 alert( '𝒳'.match(/[𝒳𝒴]/u) ); // 𝒳
 ```
 
-There's an error that may happen if we forget the flag:
+Let's see one more example.
+
+If we forget the `u` flag and occasionally use surrogate pairs, then we can get an error:
 
 ```js run
 '𝒳'.match(/[𝒳-𝒴]/); // SyntaxError: invalid range in character class
 ```
 
-Here the regexp `[𝒳-𝒴]` is treated as `[12-34]` (where `2` is the right part of `𝒳` and `3` is the left part of `𝒴`), and the range between two halves `2` and `3` is unacceptable.
+Normally, regexps understand `[a-z]` as a "range of characters with codes between codes of `a` and `z`.
 
-Using the flag would make it work right:
+But without `u` flag, surrogate pairs are assumed to be a "pair of independant characters", so `[𝒳-𝒴]` is like `[<55349><56499>-<55349><56500>]` (replaced each surrogate pair with code points). Now we can clearly see that the range `56499-55349` is unacceptable, as the left range border must be less than the right one.
+
+Using the `u` flag makes it work right:
 
 ```js run
 alert( '𝒴'.match(/[𝒳-𝒵]/u) ); // 𝒴
 ```
-
-To finalize, let's note that if we do not deal with surrogate pairs, then the flag does nothing for us. But in the modern world we often meet them.
diff --git a/9-regular-expressions/21-regexp-unicode-properties/article.md b/9-regular-expressions/21-regexp-unicode-properties/article.md
new file mode 100644
index 000000000..eac9bfbca
--- /dev/null
+++ b/9-regular-expressions/21-regexp-unicode-properties/article.md
@@ -0,0 +1,86 @@
+
+# Unicode character properies \p
+
+[Unicode](https://en.wikipedia.org/wiki/Unicode), the encoding format used by JavaScript strings, has a lot of properties for different characters (or, technically, code points). They describe which "categories" character belongs to, and a variety of technical details.
+
+In regular expressions these can be set by `\p{…}`. And there must be flag `'u'`.
+
+For instance, `\p{Letter}` denotes a letter in any of language. We can also use `\p{L}`, as `L` is an alias of `Letter`, there are shorter aliases for almost every property.
+
+Here's the main tree of properties:
+
+- Letter `L`:
+  - lowercase `Ll`, modifier `Lm`, titlecase `Lt`, uppercase `Lu`, other `Lo`
+- Number `N`:
+  - decimal digit `Nd`, letter number `Nl`, other `No`:
+- Punctuation `P`:
+  - connector `Pc`, dash `Pd`, initial quote `Pi`, final quote `Pf`, open `Ps`, close `Pe`, other `Po`
+- Mark `M` (accents etc):
+  - spacing combining `Mc`, enclosing `Me`, non-spacing `Mn`
+- Symbol `S`:
+  - currency `Sc`, modifier `Sk`, math `Sm`, other `So`
+- Separator `Z`:
+  - line `Zl`, paragraph `Zp`, space `Zs`
+- Other `C`:
+  - control `Cc`, format `Cf`, not assigned `Cn`, private use `Co`, surrogate `Cs`.
+
+```smart header="More information"
+Interested to see which characters belong to a property? There's a tool at <http://cldr.unicode.org/unicode-utilities/list-unicodeset> for that.
+
+You could also explore properties at [Character Property Index](http://unicode.org/cldr/utility/properties.jsp).
+
+For the full Unicode Character Database in text format (along with all properties), see <https://www.unicode.org/Public/UCD/latest/ucd/>.
+```
+
+There are also other derived categories, like:
+- `Alphabetic` (`Alpha`), includes Letters `L`, plus letter numbers `Nl` (e.g. roman numbers Ⅻ), plus some other symbols `Other_Alphabetic` (`OAltpa`).
+- `Hex_Digit` includes hexadimal digits: `0-9`, `a-f`.
+- ...Unicode is a big beast, it includes a lot of properties.
+
+For instance, let's look for a 6-digit hex number:
+
+```js run
+let reg = /\p{Hex_Digit}{6}/u; // flag 'u' is requireds
+
+alert("color: #123ABC".match(reg)); // 123ABC
+```
+
+There are also properties with a value. For instance, Unicode "Script" (a writing system) can be Cyrillic, Greek, Arabic, Han (Chinese) etc, the [list is long]("https://en.wikipedia.org/wiki/Script_(Unicode)").
+
+To search for certain scripts, we should supply `Script=<value>`, e.g. to search for cyrillic letters: `\p{sc=Cyrillic}`, for Chinese glyphs: `\p{sc=Han}`, etc:
+
+```js run
+let regexp = /\p{sc=Han}+/gu; // get chinese words
+
+let str = `Hello Привет 你好 123_456`;
+
+alert( str.match(regexp) ); // 你好
+```
+
+## Building multi-language \w
+
+Let's make a "universal" regexp for `pattern:\w`, for any language. That task has a standard solution in many programming languages with unicode-aware regexps, e.g. Perl.
+
+```js
+/[\p{Alphabetic}\p{Mark}\p{Decimal_Number}\p{Connector_Punctuation}\p{Join_Control}]/u
+```
+
+Let's decipher. Remember, `pattern:\w` is actually the same as `pattern:[a-zA-Z0-9_]`.
+
+So the character set includes:
+
+- `Alphabetic` for letters,
+- `Mark` for accents, as in Unicode accents may be represented by separate code points,
+- `Decimal_Number` for numbers,
+- `Connector_Punctuation` for the `'_'` character and alike,
+- `Join_Control` -– two special code points with hex codes `200c` and `200d`, used in ligatures e.g. in arabic.
+
+Or, if we replace long names with aliases (a list of aliases [here](https://www.unicode.org/Public/UCD/latest/ucd/PropertyValueAliases.txt)):
+
+```js run
+let regexp = /([\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]+)/gu;
+
+let str = `Hello Привет 你好 123_456`;
+
+alert( str.match(regexp) ); // Hello,Привет,你好,123_456
+```
diff --git a/9-regular-expressions/22-regexp-sticky/article.md b/9-regular-expressions/22-regexp-sticky/article.md
new file mode 100644
index 000000000..5a790bb31
--- /dev/null
+++ b/9-regular-expressions/22-regexp-sticky/article.md
@@ -0,0 +1,71 @@
+
+# Sticky flag "y", searching at position
+
+To grasp the use case of `y` flag, and see how great it is, let's explore a practical use case.
+
+One of common tasks for regexps is "parsing": when we get a text and analyze it for logical components, build a structure.
+
+For instance, there are HTML parsers for browser pages, that turn text into a structured document. There are parsers for programming languages, like JavaScript, etc.
+
+Writing parsers is a special area, with its own tools and algorithms, so we don't go deep in there, but there's a very common question: "What is the text at the given position?".
+
+For instance, for a programming language variants can be like:
+- Is it a "name" `pattern:\w+`?
+- Or is it a number `pattern:\d+`?
+- Or an operator `pattern:[+-/*]`?
+- (a syntax error if it's not anything in the expected list)
+
+In JavaScript, to perform a search starting from a given position, we can use `regexp.exec` with `regexp.lastIndex` property, but that's not what we need!
+
+We'd like to check the match exactly at given position, not "starting" from it.
+
+Here's a (failing) attempt to use `lastIndex`:
+
+```js run
+let str = "(text before) function ...";
+
+// attempting to find function at position 5:
+let regexp = /function/g; // must use "g" flag, otherwise lastIndex is ignored
+regexp.lastIndex = 5
+
+alert (regexp.exec(str)); // function
+```
+
+The match is found, because `regexp.exec` starts to search from the given position and goes on by the text, successfully matching "function" later.
+
+We could work around that by checking if "`regexp.exec(str).index` property is `5`, and if not, ignore the much. But the main problem here is performance.
+
+The regexp engine does a lot of unnecessary work by scanning at further positions. The delays are clearly noticeable if the text is long, because there are many such searches in a parser.
+
+## The "y" flag
+
+So we've came to the problem: how to search for a match, starting exactly at the given position.
+
+That's what `y` flag does. It makes the regexp search only at the `lastIndex` position.
+
+Here's an example
+
+```js run
+let str = "(text before) function ...";
+
+*!*
+let regexp = /function/y;
+regexp.lastIndex = 5;
+*/!*
+
+alert (regexp.exec(str)); // null (no match, unlike "g" flag!)
+
+*!*
+regexp.lastIndex = 14;
+*/!*
+
+alert (regexp.exec(str)); // function (match!)
+```
+
+As we can see, now the regexp is only matched at the given position.
+
+So what `y` does is truly unique, and very important for writing parsers.
+
+The `y` flag allows to apply a regular expression (or many of them one-by-one) exactly at the given position and when we understand what's there, we can move on -- step by step examining the text.
+
+Without the flag the regexp engine always searches till the end of the text, that takes time, especially if the text is large. So our parser would be very slow. The `y` flag is exactly the right thing here.
diff --git a/5-regular-expressions/index.md b/9-regular-expressions/index.md
similarity index 100%
rename from 5-regular-expressions/index.md
rename to 9-regular-expressions/index.md
diff --git a/AUTHORING.md b/AUTHORING.md
new file mode 100644
index 000000000..17516b583
--- /dev/null
+++ b/AUTHORING.md
@@ -0,0 +1,37 @@
+
+# Authoring
+
+This describes important stuff about authoring new articles of the tutorial.
+
+## Internal links
+
+All tutorial links should start from the root, not including the domain.
+
+✅ OK:
+
+```md
+We'll cover that in the chapter [about functions](/function-basics)
+```
+
+❌ Not ok:
+
+```md
+We'll cover that in the chapter [about functions](https://javascript.info/function-basics)
+```
+
+Also, to reference a chapter, there's a special "info:" scheme, like this:
+
+```md
+We'll cover that in the chapter <info:function-basics>.
+```
+
+Becomes:
+```html
+We'll cover that in the chapter <a href="/https/patch-diff.githubusercontent.com/function-basics">Function basics</a>.
+```
+
+The title is auto-inserted from the referenced article. That has the benefit of keeping the right title if the article gets renamed.
+
+## TODO
+
+Ask @iliakan to for more details.
diff --git a/README.md b/README.md
index 6d16cdf58..69598957f 100755
--- a/README.md
+++ b/README.md
@@ -1,9 +1,16 @@
+<<<<<<< HEAD
 # The Modern JavaScript Tutorial in Italian
 
 In questa repository viene pubblicata la traduzione italiana di <https://javascript.info>.
+=======
+# The Modern JavaScript Tutorial
+
+This repository hosts the English content of the Modern JavaScript Tutorial, published at [https://javascript.info](https://javascript.info).
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Vi chiediamo di aiutarci a rendere il processo di traduzione il più semplice possibile.
 
+<<<<<<< HEAD
 - Leggete tra gli [issue](https://github.com/javascript-tutorial/it.javascript.info/issues) quello denominato "Translate Progress".
 - Scegliete l'articolo che desiderate tradurre e mettete la spunta.
 - Create un issue per informare il gestore della repository sull'articolo scelto.
@@ -26,6 +33,21 @@ Una cartella possiede uno di questi tipi di file:
 - `index.md` per una sezione,
 - `article.md` per un articolo,
 - `task.md` per gli esercizi(+`solution.md` con la soluzione ed eventuale spiegazione).
+=======
+We'd like to make the tutorial available in many languages. Please help us to translate.
+
+See <https://github.com/javascript-tutorial/translate> for the details.
+
+## Contributions
+
+We'd also like to collaborate on the tutorial with other people.
+
+Something's wrong? A topic is missing? Explain it to people, add as PR 👏
+
+**You can edit the text in any editor.** The tutorial uses enhanced "markdown" format, easy to grasp. And if you want to see how it looks on-site, there's a server to run the tutorial locally at <https://github.com/javascript-tutorial/server>.  
+
+The list of contributors is available at <https://javascript.info/about#contributors>.
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
 
 Un file inizia con `# Title Header`, e il testo è in formato Markdown, che può esserre modificato con un semplice editor di testo. 
 
@@ -37,6 +59,7 @@ La traduzione non deve necessariamente essere fatta parola per parola. Dovrebbe
 
 Se avete dei suggerimenti per migliorare anche la versione Inglese - ottimo, inviatemi una PR e valuterò la vostra proposta.
 
+<<<<<<< HEAD
 ### Esempi ed Esercizi
 
 - I commenti possono essere tradotti
@@ -101,3 +124,12 @@ Alcuni termini utilizzati spesso:
 Potete eseguire il tutorial localmente, per vedere immediatamente i cambiamenti.
 
 Qui trovate il server: <https://github.com/javascript-tutorial/server>. 
+=======
+Each of these files starts from the `# Main header`.
+
+It's very easy to add something new.
+
+---
+💓  
+Ilya Kantor @iliakan
+>>>>>>> 273e47b70a14ae7a8b882b8d2543e581b000eefb
diff --git a/TRANSLATION.md b/TRANSLATION.md
deleted file mode 100644
index bde4be18a..000000000
--- a/TRANSLATION.md
+++ /dev/null
@@ -1,13 +0,0 @@
-
-# The JavaScript Tutorial
-
-This repository hosts the translation of the [Modern JavaScript Tutorial](https://javascript.info).
-
-The full list of translations and leads is at <https://github.com/iliakan/javascript-tutorial-en>.
-
-Please contact the translation lead for any questions. 
-Contact @iliakan there's no answer or the translation appears to be stalled. 
-
-If there are other translators, notify them (create an issue?) when you're taking a chapter.
-
-
diff --git a/figures.sketch b/figures.sketch
index e3c50f374..c740ac577 100644
Binary files a/figures.sketch and b/figures.sketch differ
diff --git a/todo.md b/todo.md
new file mode 100644
index 000000000..331e3f478
--- /dev/null
+++ b/todo.md
@@ -0,0 +1,7 @@
+
+- Drag events
+- History api
+- Pointer events
+- Touch events
+- Canvas (2d graphics)
+- Security (xsrf xss csp etc)