diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000000..6313b56c57
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+* text=auto eol=lf
diff --git a/1-js/01-getting-started/1-intro/article.md b/1-js/01-getting-started/1-intro/article.md
index ec822e83a9..38ee795352 100644
--- a/1-js/01-getting-started/1-intro/article.md
+++ b/1-js/01-getting-started/1-intro/article.md
@@ -1,9 +1,14 @@
 # JavaScript 简介
 
+<<<<<<< HEAD
 我们一起来聊一下 JavaScript，用它能做什么，它有哪些特性，以及一些跟它配合使用的技术。
+=======
+Let's see what's so special about JavaScript, what we can achieve with it, and which other technologies play well with it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 什么是 JavaScript？
 
+<<<<<<< HEAD
 **JavaScript** 最初的目的是为了“**赋予网页生命**”。
 
 这种编程语言我们称之为**脚本**。它们可以写在 HTML 中，在页面加载的时候会自动执行。
@@ -31,6 +36,35 @@ JavaScript 在刚诞生的时候，它的名字叫 “LiveScript”。但是因
 上面这些很容易记忆，因为经常出现在网上关于开发的文章中。我们也会这样用。例如：某个新的功能，如果 JavaScript 引擎 V8 是支持的，那么我们可以认为这个功能在 Chrome 和 Opera 中可以正常运行。
 
 ```smart header="引擎是如何工作的？"
+=======
+*JavaScript* was initially created to *"make web pages alive"*.
+
+The programs in this language are called *scripts*. They can be written right in a web page's HTML and run automatically as the page loads.
+
+Scripts are provided and executed as plain text. They don't need special preparation or compilation to run.
+
+In this aspect, JavaScript is very different from another language called [Java](https://en.wikipedia.org/wiki/Java_(programming_language)).
+
+```smart header="Why <u>Java</u>Script?"
+When JavaScript was created, it initially had another name: "LiveScript". But Java was very popular at that time, so it was decided that positioning a new language as a "younger brother" of Java would help.
+
+But as it evolved, JavaScript became a fully independent language with its own specification called [ECMAScript](http://en.wikipedia.org/wiki/ECMAScript), and now it has no relation to Java at all.
+```
+
+Today, JavaScript can execute not only in the browser, but also on the server, or actually on any device that has a special program called [the JavaScript engine](https://en.wikipedia.org/wiki/JavaScript_engine).
+
+The browser has an embedded engine sometimes called a "JavaScript virtual machine".
+
+Different engines have different "codenames". For example:
+
+- [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- in Chrome and Opera.
+- [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- in Firefox.
+- ...There are other codenames like "Trident" and "Chakra" for different versions of IE, "ChakraCore" for Microsoft Edge, "Nitro" and "SquirrelFish" for Safari, etc.
+
+The terms above are good to remember because they are used in developer articles on the internet. We'll use them too. For instance, if "a feature X is supported by V8", then it probably works in Chrome and Opera.
+
+```smart header="How do engines work?"
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 引擎很复杂，但是基本原理很简单。
 
@@ -38,16 +72,28 @@ JavaScript 在刚诞生的时候，它的名字叫 “LiveScript”。但是因
 2. 然后将脚本转化（“编译”）为机器语言。
 3. 然后就可以在机器上飞速的运行。
 
+<<<<<<< HEAD
 引擎会对流程中的每个阶段都进行优化。它甚至可以在运行时监视编译的脚本，分析数据流并根据这些对机器代码应用优化。最后，脚本会执行地非常快。
+=======
+The engine applies optimizations at each step of the process. It even watches the compiled script as it runs, analyzes the data that flows through it, and applies optimizations to the machine code based on that knowledge. When it's done, scripts run quite fast.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ## 浏览器中的 JavaScript 能做什么 ?
 
+<<<<<<< HEAD
 现代的 JavaScript 是一种“安全”语言。它不提供对内存或 CPU 的底层访问，因为它最初是为浏览器创建的，不需要这些功能。
 
 JavaScript 的能力依赖于它执行的环境。例如：[Node.js](https://wikipedia.org/wiki/Node.js) 允许 JavaScript 读写任意文件、执行网络请求等。
 
 浏览器中的 JavaScript 可以完成所有和网页相关的操作、处理用户和 Web 服务器之间的交互。
+=======
+Modern JavaScript is a "safe" programming language. It does not provide low-level access to memory or CPU, because it was initially created for browsers which do not require it.
+
+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.
+
+In-browser JavaScript can do everything related to webpage manipulation, interaction with the user, and the webserver.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如，浏览器中的 JavaScript 可以完成下面这些事：
 
@@ -61,7 +107,11 @@ JavaScript 的能力依赖于它执行的环境。例如：[Node.js](https://wik
 
 为了用户的（信息）安全，在浏览器中的 JavaScript 的能力是有限的。这样主要是为了阻止邪恶的网站获得或修改用户的私人数据。
 
+<<<<<<< HEAD
 这些限制的例子有：
+=======
+Examples of such restrictions include:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 * 网页中的 JavaScript 不能读、写、复制及执行用户磁盘上的文件或程序。它没有直接访问操作系统的功能。
 
@@ -70,6 +120,7 @@ JavaScript 的能力依赖于它执行的环境。例如：[Node.js](https://wik
   JavaScript 有很多方式和设备的照相机/麦克风交互，但是这些都需要提前获得用户的授权许可。所以，JavaScript 并不会偷偷地通过你的摄像头观察你，更不会把你的信息发送到[美国国家安全局](https://en.wikipedia.org/wiki/National_Security_Agency)。
 - 不同的浏览器标签页之间基本彼此不相关。有时候，也会有一些关系。例如，通过 JavaScript 打开另外一个新的标签页。但即使在这种情况下，如果两个标签页打开的不是同一个网站（域名、协议或者端口任一不相同的网站），他们都不能够相互通信。
 
+<<<<<<< HEAD
   这就是“同源策略”。为了解决不同标签页交互的问题，两个同源的网站必须**都**包含一些特殊的 JavaScript 代码，才能够实现数据交换。
 
   这个限制也是为了用户的信息安全。例如，用户打开的 `http://anysite.com` 网页的 JavaScript 不能访问 `http://gmail.com`（另外一个标签页打开的网页）也不能从那里窃取信息。
@@ -78,22 +129,45 @@ JavaScript 的能力依赖于它执行的环境。例如：[Node.js](https://wik
 ![](limitations.png)
 
 浏览器环境外的 JavaScript 一般没有这些限制。例如服务端的 JavaScript 就没有这些限制。现代浏览器还允许通过 JavaScript 来安装浏览器插件或扩展，当然这也是在用户授权的前提下。
+=======
+    This is called the "Same Origin Policy". To work around that, *both pages* must agree for data exchange and contain a special JavaScript code that handles it. We'll cover that in the tutorial.
+
+    This limitation is, again, for the user's safety. A page from `http://anysite.com` which a user has opened must not be able to access another browser tab with the URL `http://gmail.com` and steal information from there.
+- JavaScript can easily communicate over the net to the server where the current page came from. But its ability to receive data from other sites/domains is crippled. Though possible, it requires explicit agreement (expressed in HTTP headers) from the remote side. Once again, that's a safety limitation.
+
+![](limitations.png)
+
+Such limits do not exist if JavaScript is used outside of the browser, for example on a server. Modern browsers also allow plugin/extensions which may ask for extended permissions.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## JavaScript 为什么与众不同？
 
 至少有 **3** 件事值得一提：
 
 ```compare
+<<<<<<< HEAD
 + 和 HTML/CSS 完全的集成。
 + 使用简单的工具完成简单的任务。
 + 被所有的主流浏览器支持，并且默认开启。
+=======
++ Full integration with HTML/CSS.
++ Simple things are done simply.
++ Support by all major browsers and enabled by default.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
+JavaScript is the only browser technology that combines these three things.
 
+<<<<<<< HEAD
 满足这三条的浏览器技术也只有 JavaScript 了。
 
 这就是为什么 JavaScript 与众不同！这也是为什么它是创建浏览器界面的最普遍的工具。
 
 当然，学习一项新技术的时候，最好先看一下它的前景。所以，接下来我们继续讨论包括新语言和浏览器功能在内的现代趋势。
+=======
+That's what makes JavaScript unique. That's why it's the most widespread tool for creating browser interfaces.
+
+While planning to learn a new technology, it's beneficial to check its perspectives. So let's move on to the modern trends affecting it,  including new languages and browser abilities.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 
 ## 比 JavaScript “好” 的语言
@@ -104,18 +178,36 @@ JavaScript 的能力依赖于它执行的环境。例如：[Node.js](https://wik
 
 所以，最近出现了很多不同的语言，这些语言在浏览器中执行之前，都会被**编译**（转化）成 JavaScript。
 
+<<<<<<< HEAD
 现代化的工具使得编译速度非常快速和透明，实际上允许开发人员使用另一种语言编写代码并将其自动转换为 JavaScript。
+=======
+Modern tools make the transpilation very fast and transparent, actually allowing developers to code in another language and auto-converting it "under the hood".
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这些语言的例子有：
 
+<<<<<<< HEAD
 - [CoffeeScript](http://coffeescript.org/) 是 JavaScript 的语法糖，它语法简短，明确简洁。通常使用 Ruby 的人喜欢用。
 - [TypeScript](http://www.typescriptlang.org/) 将注意力集中在增加严格的数据类型。这样就能简化开发，也能用于开发复杂的系统。TypeScript 是微软开发的。
 - [Dart](https://www.dartlang.org/) 是一门独立的语言。它拥有自己的引擎用于在非浏览器环境中运行（如：在手机应用中运行）。最开始是 Google 提供的用于替代 JavaScript 的，但是现在，它和其他上述的语言一样，浏览器也要求它被编译成 JavaScript 。
 
 当然，还有更多其他的语言。即使我们在使用这些语言，我们也需要知道 JavaScript。因为学习 JavaScript 可以让我们真正明白我们自己在做什么。
+=======
+- [CoffeeScript](http://coffeescript.org/) is a "syntactic sugar" for JavaScript. It introduces shorter syntax, allowing us to write clearer and more precise code. Usually, Ruby devs like it.
+- [TypeScript](http://www.typescriptlang.org/) is concentrated on adding "strict data typing" to simplify the development and support of complex systems. It is developed by Microsoft.
+- [Dart](https://www.dartlang.org/) is a standalone language that has its own engine that runs in non-browser environments (like mobile apps). It was initially offered by Google as a replacement for JavaScript, but as of now, browsers require it to be transpiled to JavaScript just like the ones above.
+
+There are more. Of course, even if we use one of these languages, we should also know JavaScript to really understand what we're doing.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 总结
 
+<<<<<<< HEAD
 - JavaScript 最开始是为浏览器设计的一门语言，但是现在也可以在其它的环境中运行。
 - 现在，JavaScript 是一门在浏览器中使用最广、并且能够很好集成 HTML/CSS 的语言。
 - 有很多其他的语言可以编译成 JavaScript，这些语言还提供更多的功能。最好要了解一下这些语言，至少需要在掌握 JavaScript 之后简单地看一下。
+=======
+- JavaScript was initially created as a browser-only language, but is now used in many other environments as well.
+- Today, JavaScript has a unique position as the most widely-adopted browser language with full integration with HTML/CSS.
+- There are many languages that get "transpiled" to JavaScript and provide certain features. It is recommended to take a look at them, at least briefly, after mastering JavaScript.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/1-js/01-getting-started/1-intro/limitations.png b/1-js/01-getting-started/1-intro/limitations.png
index d5d315c5c1..3ef6b1e087 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 01483997da..7aa1c41ae4 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 64cea6a40b..4027264641 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 @@
 
 程序员接触时间最长的就是代码编辑器（后面简称编辑器）。
 
+<<<<<<< HEAD
 编辑器主要分两种：IDE（集成开发环境）和轻量编辑器。很多人喜欢这两种各选一个。
 
 ## IDE
@@ -19,12 +20,36 @@ IDE 加载项目（通常包含多个文件），并且允许在不同文件之
 除了 Visual Studio，以上这些 IDE 都是跨平台的。Visual Studio 无法在 Linux 上使用。
 
 大多数 IDE 是收费的，但是他们都可以试用。这些费用对于一个合格的程序员的薪水来说，肯定算不了什么，所以去选一个对你来说最好的吧。
+=======
+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/).
+
+Many IDEs are paid but have a trial period. Their cost is usually negligible compared to a qualified developer's salary, so just choose the best one for you.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 轻量编辑器
 
 “轻量编辑器”没有 IDE 那么功能强大，但是他们一般很快、优雅而且简单。
 
+<<<<<<< HEAD
 “轻量编辑器”主要用于立即打开编辑一个文件。
+=======
+They are mainly used to open and edit a file instantly.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 “轻量编辑器”和 IDE 有很大的区别。IDE 一般是项目中使用，就意味着一开始要加载很多数据，并且在使用的过程中会分析项目的结构和内容。如果我们只需要编辑一个文件，那么 “轻量编辑器” 会更快的帮我们打开文件。
 
@@ -32,11 +57,19 @@ IDE 加载项目（通常包含多个文件），并且允许在不同文件之
 
 下面是一些流行的“轻量编辑器”：
 
+<<<<<<< HEAD
 - [Visual Studio Code](https://code.visualstudio.com/)（跨平台、免费）。
 - [Atom](https://atom.io/)（跨平台、免费）。
 - [Sublime Text](http://www.sublimetext.com)（跨平台、共享软件）。
 - [Notepad++](https://notepad-plus-plus.org/)（Windows、免费）。
 - [Vim](http://www.vim.org/) 和 [Emacs](https://www.gnu.org/software/emacs/) 很棒，前提是如果你知道怎么用。
+=======
+- [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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 我的最爱
 
@@ -44,13 +77,26 @@ IDE 加载项目（通常包含多个文件），并且允许在不同文件之
 
 我使用的编辑器：
 
+<<<<<<< HEAD
 - 使用 [WebStorm](http://www.jetbrains.com/webstorm/) 写 JavaScript，如果项目涉及其他语言我切换到上面列出的其他 Jetbrains 产品之一。
 - 轻量编辑器 —— [Sublime Text](http://www.sublimetext.com) 或 [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/).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 不要争吵
 
+<<<<<<< HEAD
 上面列表中的编辑器都是我或我的朋友（他们都是我认为很优秀的开发人员）已经使用了很长时间并且很满意的。
+=======
+The editors in the lists above are those that either I or my friends whom I consider good developers have been using for a long time and are happy with.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 世上还有很多其他的很好的编辑器，你们可以选择一个自己最喜欢的。
 
+<<<<<<< HEAD
 选择编辑器就像选择其他工具一样。要看你的项目，以及个人的习惯、喜好。
+=======
+The choice of an editor, like any other tool, is individual and depends on your projects, habits, and personal preferences.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/1-js/01-getting-started/3-devtools/article.md b/1-js/01-getting-started/3-devtools/article.md
index be0ea58fbf..b35beb8b09 100644
--- a/1-js/01-getting-started/3-devtools/article.md
+++ b/1-js/01-getting-started/3-devtools/article.md
@@ -1,5 +1,6 @@
 # 开发者控制台
 
+<<<<<<< HEAD
 代码是很容易出现错误的。你也很可能犯错误...... 哦，我在说什么？只要你是人，你一定会犯错误（在写代码的时候），除非你是[机器人](https://en.wikipedia.org/wiki/Bender_(Futurama))。
 
 但在浏览器中，默认情况下用户是看不到错误的。所以，如果脚本中有错误，我们看不到是什么错误，更不能够修复。
@@ -9,6 +10,17 @@
 通常，开发者倾向于使用 Chrome 或 Firefox 来开发，因为它们有最好的开发者工具。一些其他的浏览器也提供开发者工具，有时还具有一些特殊的功能，通常它们都是在追赶 Chrome 或 Firefox。所以大多数人都有 “最喜欢” 的浏览器，当遇到某个浏览器独有的问题的时候，人们就会切换到其他的浏览器。
 
 开发者工具很强大，功能丰富。首先，我们要学习如何打开它们，查找错误和运行 JavaScript 命令。
+=======
+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.
+
+To see errors and get a lot of other useful information about scripts, "developer tools" have been embedded in browsers.
+
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## Google Chrome
 
@@ -24,6 +36,7 @@
 
 ![chrome](chrome.png)
 
+<<<<<<< HEAD
 具体什么样，要看你的 Chrome 版本。它随着时间一直在变，但是都很类似。
 
 - 上面这个，我们能看到红色的错误信息。这个场景中，脚本里有一个未知的 “lalala” 命令。
@@ -32,26 +45,65 @@
 在错误信息的下方，有个 `>` 标志。它代表 “命令行”，在 “命令行” 中，我们可以输入 JavaScript 命令，按下 `key:Enter` 来执行（`key:Shift+Enter` 用来输入多行命令）。
 
 现在，我们能看到错误就够了。稍后，在 <info:debugging-chrome> 章节中，我们会重新更加深入地讨论开发者工具。
+=======
+The exact look of developer tools depends on your version of Chrome. It changes from time to time but should be similar.
+
+- Here we can see the red-colored error message. In this case, the script contains an unknown "lalala" command.
+- On the right, there is a clickable link to the source `bug.html:12` with the line number where the error has occurred.
+
+Below the error message, there is a blue `>` symbol. It marks a "command line" where we can type JavaScript commands. Press `key:Enter` to run them (`key:Shift+Enter` to input multi-line commands).
+
+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>.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## Firefox、Edge 和其他
 
+<<<<<<< HEAD
 大多数其他的浏览器都是通过 `key:F12` 来打开开发者工具。
 
 他们的外观和感觉都非常相似，一旦你学会了他们中的一个（可以先尝试 Chrome），其他的也就很快了。
+=======
+## Firefox, Edge, and others
+
+Most other browsers use `key:F12` to open developer tools.
+
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## Safari
 
 Safari（Mac 系统中浏览器，不支持 Windows 和 Linux 系统）有一点点不同。我们需要先开启 “开发菜单”。
 
+<<<<<<< HEAD
 打开 “偏好设置”，选择“高级”选项。选中最下方的那个选择框。
 
 ![safari](safari.png)
 
 现在，我们通过 `key:Cmd+Opt+C` 就能打开或关闭控制台了。另外注意，有一个名字为 “开发” 的顶部菜单出现了。它有很多命令和选项。
+=======
+Open Preferences and go to the "Advanced" pane. There's a checkbox at the bottom:
+
+![safari](safari.png)
+
+Now `key:Cmd+Opt+C` can toggle the console. Also, note that the new top menu item named "Develop" has appeared. It has many commands and options.
+
+## 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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 总结
 
+<<<<<<< HEAD
 * 开发者工具允许我们查看错误、执行命令、检查变量等等。
 * 在 Windows 系统中，可以通过 `key:F12` 开启开发者工具。Mac 系统下，Chrome 需要使用 `key:Cmd+Opt+J`，Safari 使用 `key:Cmd+Opt+C`（需要提前开启）。
 
 现在我们的环境准备好了，下一章，我们将开始讨论 JavaScript。
+=======
+- 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).
+
+Now we have the environment ready. In the next section, we'll get down to JavaScript.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 0727719bcc..b1192532dd 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
 你现在所阅读的这个教程是 JavaScript 的核心内容，这部分内容是平台无关的。接下来，你将会学习 Node.js 以及使用 Node.js 的其他平台。
 
 但是，我们需要一个工作环境来运行代码，由于本书是在线的，所以浏览器是一个不错的选择。我们会尽可能少地使用浏览器特定的命令（比如 `alert`），所以如果你打算使用如 Node.js 的其他环境，你不必多花时间来关心这些特定指令。另一方面，浏览器的具体细节我们会在教程的[下一部分](/ui)介绍。
 
 首先，让我们看看如何将脚本添加到网页上。对于服务器端环境，你只需要使用诸如 `"node my.js"` 的 Node.js 的命令行来执行它。
+=======
+This part of the tutorial is about core JavaScript, the language itself. 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"`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## "script" 标签
 
 JavaScript 程序可以使用 `<script>` 标签插入到 HTML 的任何地方。
 
+<<<<<<< HEAD
 比如：
+=======
+JavaScript programs can be inserted into any part of an HTML document with the help of the `<script>` tag.
+
+For instance:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html run height=100
 <!DOCTYPE HTML>
@@ -34,6 +48,7 @@ JavaScript 程序可以使用 `<script>` 标签插入到 HTML 的任何地方。
 ```
 
 ```online
+<<<<<<< HEAD
 你可以通过点击右上角的“播放”按钮来运行这个例子。
 ```
 
@@ -53,6 +68,26 @@ JavaScript 程序可以使用 `<script>` 标签插入到 HTML 的任何地方。
 
 脚本前后的注释。
 : 在非常古老的书籍和指南中，可能会在 `<script>` 标签里面找到注释，就像这样：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```html no-beautify
     <script type="text/javascript"><!--
@@ -60,24 +95,40 @@ JavaScript 程序可以使用 `<script>` 标签插入到 HTML 的任何地方。
     //--></script>
     ```
 
+<<<<<<< HEAD
     这些注释是给不支持 `<script>` 标签的古老浏览器用来隐藏代码的。但是所有在过去的 15+ 年中诞生的浏览器都没有任何问题。只是因为它作为一个标志，所以我们在这里提到。如果你在某个地方看到了它，那么这些代码可能非常古老，也不值得我们去研究。
+=======
+    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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 
 ## 外部脚本
 
 如果你有大量的 JavaScript 代码，我们可以将它放入一个单独的文件。
 
+<<<<<<< HEAD
 脚本文件可以通过 `src` 属性添加到 HTML 文件中。
+=======
+Script files are attached to HTML with the `src` attribute:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html
 <script src="/path/to/script.js"></script>
 ```
 
+<<<<<<< HEAD
 这里，`/path/to/script.js` 是脚本文件的绝对路径（从站点根目录开始）。
 
 也可以提供相对于当前页面的相对路径。比如，`src="script.js"` 意思是来自当前文件夹的 `"script.js"` 文件。
 
 我们还可以提供一个完整的 URL 地址，例如：
+=======
+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.
+
+We can give a full URL as well. For instance:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html
 <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.2.0/lodash.js"></script>
@@ -94,6 +145,7 @@ JavaScript 程序可以使用 `<script>` 标签插入到 HTML 的任何地方。
 ```smart
 一般来说，只有最简单的脚本才嵌入到 HTML。更复杂的脚本存放在单独的文件中。
 
+<<<<<<< HEAD
 使用独立文件的好处是浏览器会下载它，然后将它保存到浏览器的[缓存](https://en.wikipedia.org/wiki/Web_cache)中。
 
 之后，其他页面想要相同的脚本就会从缓存中获取，而不是下载它。所以文件实际上只会下载一次。
@@ -103,6 +155,17 @@ JavaScript 程序可以使用 `<script>` 标签插入到 HTML 的任何地方。
 
 ````warn header="如果设置了 `src`属性，`script` 标签内容将会忽略。"
 单独的一个 `<script>` 标签不能同时有 src 属性以及内部包裹代码。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这将不会工作：
 
@@ -112,7 +175,11 @@ JavaScript 程序可以使用 `<script>` 标签插入到 HTML 的任何地方。
 </script>
 ```
 
+<<<<<<< HEAD
 我们必须选择，要么外部的`<script src="…">`，要么正常包裹代码的`<script>`。
+=======
+We must choose either an external `<script src="…">` or a regular `<script>` with code.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 为了让上面的例子工作，我们将它分成两个 `<script>` 标签。
 
@@ -126,9 +193,18 @@ JavaScript 程序可以使用 `<script>` 标签插入到 HTML 的任何地方。
 
 ## 总结
 
+<<<<<<< HEAD
 - 我们可以使用一个 `<script>` 标签将 JavaScript 代码添加到页面中。
 - `type` 和 `language` 属性不是必需的。
 - 外部的脚本可以通过 `<script src="path/to/script.js"></script>` 这种方式插入。
 
 
 有关浏览器脚本以及它们和网页的关系，还有很多可学的。但是请记住，这部分教程主要是针对 JavaScript 语言的，所以我们不该分散自己的注意力。我们使用浏览器作为运行 JavaScript 的一种方式，非常便于我们在线阅读。
+=======
+- 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>`.
+
+
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 ffe810697c..ba94e017d6 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 c4411027ca..9b2d4479f6 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 7b5c702fd7..47387ef906 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -1,22 +1,38 @@
 # 代码结构
 
+<<<<<<< HEAD
 第一件需要学习的事情就是构建代码块。
+=======
+The first thing we'll study is the building blocks of code.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 语句
 
 语句是执行操作的语法结构和命令。
 
+<<<<<<< HEAD
 我们已经见过语句 `alert('Hello, world!')`，可以用来显示消息。
 
 我们可以在代码中编写任意数量的语句。语句之间可以使用分号分割。
 
 例如，我们将 Hello World 这条信息一分为二：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run no-beautify
 alert('Hello'); alert('World');
 ```
 
+<<<<<<< HEAD
 通常，每条语句在单独的一行书写 —— 这会提高代码的可读性。
+=======
+Usually, statements are written on separate lines to make the code more readable:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run no-beautify
 alert('Hello');
@@ -34,11 +50,19 @@ alert('Hello')
 alert('World')
 ```
 
+<<<<<<< HEAD
 此处，JavaScript 将分行符解释成“隐式”的分号。这也被称为[自动分号插入](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion)。
 
 **多数情况下，换行意味着一个分号。但是“多数情况”并不意味着“总是”！**
 
 有很多换行并不是分号的例子，比如：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run no-beautify
 alert(3 +
@@ -46,7 +70,11 @@ alert(3 +
 + 2);
 ```
 
+<<<<<<< HEAD
 代码输出 `6`，因为 JavaScript 并没有在这里插入分号。 显而易见的是，如果一行以加号 `"+"` 结尾，那么这是一个“不完整的表达式”，不需要分号。所以，这个例子得到了预期的结果。
+=======
+The code outputs `6` because JavaScript does not insert semicolons here. It is intuitively obvious that if the line ends with a plus `"+"`, then it is an "incomplete expression", so the semicolon is not required. And in this case that works as intended.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 **但存在 JavaScript 无法假设分号是否真正被需要的情况。**
 
@@ -59,9 +87,15 @@ alert(3 +
 [1, 2].forEach(alert)
 ```
 
+<<<<<<< HEAD
 不需要考虑方括号 `[]` 和 `forEach` 的含义，我们接下来会学习它们，现在它们并不重要。让我们记住最终结果：先显示 `1`，然后显示 `2`。
 
 现在我们在代码前面加入一个 `alert`，并且不用分号结束它。
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run no-beautify
 alert("There will be an error")
@@ -69,7 +103,11 @@ alert("There will be an error")
 [1, 2].forEach(alert)
 ```
 
+<<<<<<< HEAD
 现在，如果我们运行代码，仅仅第一个 `alert` 显示了文本，接着我们收到了一个错误！
+=======
+Now if we run the code, only the first `alert` is shown and then we have an error!
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 但是，如果我们在第一个 `alert` 后加入一个分号，就工作正常了：
 ```js run
@@ -78,27 +116,49 @@ alert("All fine now");
 [1, 2].forEach(alert)
 ```
 
+<<<<<<< HEAD
 现在，我们能得到 "All fine now" ，然后是 `1` 和 `2`。
 
 
 出现无分号变量的错误，是因为 JavaScript 并不在方括号 `[...]` 前添加一个隐式的分号。
 
 所以，因为分号并不会自动插入，第一个例子被视为一条简单的语句，我们从引擎看到的是这样子的：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run no-beautify
 alert("There will be an error")[1, 2].forEach(alert)
 ```
 
+<<<<<<< HEAD
 但它应该是两条语句，而不是一条。这种情况下的合并是不对的，所以才会造成错误。诸如此类，还有很多。
 ````
 
 如果语句被换行分割，非常建议在语句之间添加分号。这个规则被社区广泛采纳。让我们再次强调 —— 大部分时候可以省略分号，但是最好是，尤其对于新手，加上它。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 注释
 
+<<<<<<< HEAD
 随着时间推移，程序变得越来越复杂。为代码添加**注释**来描述发生了什么（What happens）和为什么（Why），变得非常有必要了。
 
 注释可以在脚本的任何地方添加，它们并不会影响代码的执行，因为引擎会简单地忽略它们。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 **单行注释以两个正斜杠字符 `//` 开始。**
 
@@ -124,9 +184,15 @@ alert('Hello');
 alert('World');
 ```
 
+<<<<<<< HEAD
 注释的内容被忽略了，所以如果我们在 <code>/&#42; ... &#42;/</code> 中放入代码，并不会执行。
 
 有时候，可以很方便地临时禁用代码：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 /* 注释代码
@@ -135,8 +201,13 @@ alert('Hello');
 alert('World');
 ```
 
+<<<<<<< HEAD
 ```smart header="使用热键！"
 在大多数的编辑器中，一行代码可以使用 `key:Ctrl+/` 热键进行单行注释，诸如 `key:Ctrl+Shift+/` 的热键可以进行多行注释（选择代码，然后按下热键）。对于 Mac 电脑，应使用 `key:Cmd` 而不是 `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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ````warn header="不支持注释嵌套！"
@@ -154,6 +225,12 @@ alert( 'World' );
 
 注释你的代码，请不要有任何迟疑。
 
+<<<<<<< HEAD
 注释会增加代码总量，但这一点也不是问题。有很多工具可以在你部署到服务器之前缩减代码。这些工具会移除注释，所以注释不会出现在发布的脚本中。所以，注释对我们的生产没有任何负面影响。
 
 在进一步的教程中，会有一章 <info:coding-style> 的内容解释如何书写更好的注释。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 bb283c5cbd..cb82bf8ab7 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 @@
 # 新模式，"use strict"
 
+<<<<<<< HEAD
 长久以来，JavaScript 不断发展且并未带来任何兼容性问题。新特性被加入该语言，旧的功能也没有改变。
 
 这么做有利于兼容旧代码，但缺点是 JavaScript 创造者的任何错误和不完美的考虑也永远地保留在了语言中。
@@ -11,6 +12,19 @@
 这个指令看上去是一个字符串 `"use strict"` 或者 `'use strict'`。当它处于脚本文件的顶部时，则整个脚本文件都将以“现代”模式进行工作。
 
 比如：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 "use strict";
@@ -21,6 +35,7 @@
 
 稍后我们才会学习函数（一种组合命令的方式）。
 
+<<<<<<< HEAD
 但我们可以提前了解一下，`"use strict"` 可以放在函数（大多数函数）而不是整个脚本的开头。那么严格模式仅在该函数中启用。但通常人们会将它用于整个脚本。
 
 
@@ -32,6 +47,19 @@
 ```js no-strict
 alert("some code");
 // 下面的 "use strict" 会被忽略，必须在最顶部。
+=======
+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.
+
+
+````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:
+
+```js no-strict
+alert("some code");
+// "use strict" below is ignored--it must be at the top
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 "use strict";
 
@@ -41,14 +69,40 @@ alert("some code");
 只有注释可以出现在 `"use strict"` 的上面。
 ````
 
+<<<<<<< HEAD
 ```warn header="没有办法取消 `use strict`"
 没有类似于 `"no use strict"` 这样的指令可以使程序返回默认模式。
 
 一旦进入了严格模式，就没有退路了。
+=======
+```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...
+})()
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ## 总是使用 "use strict"
 
+<<<<<<< HEAD
 使用 `"use strict"` 与“默认”模式的区别仍然有待完善。
 
 在接下来的章节中，当我们学习语言功能时，我们会记录严格模式的差异。幸运的是，没有那么多。实际上，它们为我们编写代码提供了极大的便利。
@@ -59,3 +113,15 @@ alert("some code");
 2. 严格模式通过顶部的 `"use strict"` 启用。一些新语言特性诸如 "classes" 和 "modules" 也会自动开启严格模式。
 3. 所有的现代浏览器都支持严格模式。
 4. 建议始终使用 `"use strict"` 启动脚本。本教程的所有例子都默认采用严格模式，除非特别指定（非常少）。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/1-js/02-first-steps/04-variables/2-declare-variables/solution.md b/1-js/02-first-steps/04-variables/2-declare-variables/solution.md
index 65194ae7d9..2fecf89655 100644
--- a/1-js/02-first-steps/04-variables/2-declare-variables/solution.md
+++ b/1-js/02-first-steps/04-variables/2-declare-variables/solution.md
@@ -18,4 +18,8 @@ let currentUserName = "John";
 
 现代编辑器的自动补全可以让长变量名变得容易书写。不要浪费这个特性。一个名字中包含三个词就挺好的。
 
+<<<<<<< HEAD
 如果你的编辑器没有合适的自动补全，换[一个新的吧](/code-editors)。
+=======
+And if your editor does not have proper autocompletion, get [a new one](/code-editors).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 a048299cf6..0e411f1780 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
 
 # 给出正确的名字
 
+<<<<<<< HEAD
 1. 使用我们的星球的名字创建一个变量。你会怎么命名这个变量？
 2. 创建一个变量来存储当前浏览者的名字。你会怎么命名这个变量？
+=======
+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?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md
index e5b2a3ae17..2bedd03b5a 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 @@
 # 变量
 
+<<<<<<< HEAD
 大多数情况下，脚本需要处理信息。这有两个例子：
 1. 一个网上商店 —— 这里的信息可能包含正在售卖的商品和购物车
 2. 一个聊天应用 —— 这里的信息可能包括用户、消息等等。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 变量就是用来储存这些信息的。
 
 ## 一个变量
 
+<<<<<<< HEAD
 一个 [变量](https://en.wikipedia.org/wiki/Variable_(computer_science)) 是数据的“命名存储”。我们可以使用变量来保存商品、访客和其他信息。
 
 在 JavaScript 中创建一个变量，我们需要用到 `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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 下面的语句创建（换句话说，**声明**或者**定义**）了一个名称为 "message" 的变量：
 
@@ -18,7 +30,11 @@
 let message;
 ```
 
+<<<<<<< HEAD
 现在，通过赋值操作符 `=` 为变量添加一些数据：
+=======
+Now, we can put some data into it by using the assignment operator `=`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 let message;
@@ -39,7 +55,11 @@ alert(message); // 显示变量内容
 */!*
 ```
 
+<<<<<<< HEAD
 简洁一点，我们将变量定义和赋值合并成一行：
+=======
+To be concise, we can combine the variable declaration and assignment into a single line:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let message = 'Hello!'; // 定义变量，并且赋值
@@ -53,7 +73,11 @@ alert(message); // Hello!
 let user = 'John', age = 25, message = 'Hello';
 ```
 
+<<<<<<< HEAD
 看上去代码长度更短，但并不推荐。为了更好的可读性，请一行声明一个变量。
+=======
+That might seem shorter, but we don't recommend it. For the sake of better readability, please use a single line per variable.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 多行变量声明有点长，但更容易阅读：
 
@@ -63,7 +87,11 @@ let age = 25;
 let message = 'Hello';
 ```
 
+<<<<<<< HEAD
 一些程序员采用下面的形式书写多个变量：
+=======
+Some people also define multiple variables in this multiline style:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```js no-beautify
 let user = 'John',
   age = 25,
@@ -78,19 +106,33 @@ let user = 'John'
   , message = 'Hello';
 ```
 
+<<<<<<< HEAD
 技术上讲，这些变体都有一样的效果。所以，这是个个人品味和审美方面的问题。
 
 
 ````smart header="`var` 而不是 `let`"
 在较旧的脚本中，你也可能发现另一个关键字 `var`，而不是 `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`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 *!*var*/!* message = 'Hello';
 ```
 
+<<<<<<< HEAD
 `var` 关键字与 `let` **大体**相同，也用来声明变量，但稍微有些不同，也有点“老派”。
 
 `let` 和 `var` 之间有些微妙的差别，但目前对于我们来说并不重要。我们将会在 <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>.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ````
 
 ## 一个现实生活的类比
@@ -101,10 +143,15 @@ let user = 'John'
 
 ![](variable.png)
 
+<<<<<<< HEAD
 我们可以在盒子内放入任何值。
 
 同样，我们也可以改变它。值可以根据需要多次改变。
+=======
+We can put any value in the box.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
+We can also change it as many times as we want:
 ```js run
 let message;
 
@@ -136,29 +183,51 @@ alert(hello); // Hello world!
 alert(message); // Hello world!
 ```
 
+<<<<<<< HEAD
 ```smart header="函数式语言"
 有趣的是，也存在禁止更改变量值的[函数式](https://en.wikipedia.org/wiki/Functional_programming)编程语言。比如，[Scala](http://www.scala-lang.org/) 或者 [Erlang](http://www.erlang.org/)。
+=======
+```smart header="Functional languages"
+It's interesting to note that there exist [functional](https://en.wikipedia.org/wiki/Functional_programming) programming languages, like [Scala](http://www.scala-lang.org/) or [Erlang](http://www.erlang.org/) that forbid changing variable values.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在这种类型的语言中，一旦值保存在盒子中，就永远存在。如果你试图保存其他值，它会强制创建一个新盒子（声明一个新变量），无法重用先前的变量。
 
+<<<<<<< HEAD
 虽然看上去有点奇怪，但是这些语言有很大的发展潜力。不仅如此，在某些领域，比如并行计算，这个限制有一定的好处。研究这样的一门语言（即使不打算很快就用上它）有助于开阔视野。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ## 变量命名 [#variable-naming]
 
+<<<<<<< HEAD
 JavaScript 的变量命名有两个限制：
 
 1. 变量名称必须仅包含字母，数字，符号 `$` and `_`。
 2. 首字符必须非数字。
 
 有效的命名，例如：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 let userName;
 let test123;
 ```
 
+<<<<<<< HEAD
 如果命名包括多个单词，通常采用驼峰式命名法（[camelCase](https://en.wikipedia.org/wiki/CamelCase)）。也就是，单词一个接一个，每个单词以大写字母开头：`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 except first starting with a capital letter: `myVeryLongName`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 有趣的是，美元符号 `'$'` 和下划线 `'_'` 也可以在命名中使用。它们是正常的符号，就跟字母一样，没有任何特殊的含义。
 
@@ -176,6 +245,7 @@ alert($ + _); // 3
 ```js no-beautify
 let 1a; // 不能以数字开始
 
+<<<<<<< HEAD
 let my-name; // 连字符 '-' 不允许在命名中出现
 ```
 
@@ -185,6 +255,17 @@ let my-name; // 连字符 '-' 不允许在命名中出现
 
 ````smart header="允许非英文字母，但不推荐"
 可以使用任何语言，包括西里尔字母（cyrillic letters）甚至是象形文字，就像这样：
+=======
+let my-name; // hyphens '-' aren't allowed in the name
+```
+
+```smart header="Case matters"
+Variables named `apple` and `AppLE` are two different variables.
+```
+
+````smart header="Non-Latin letters are allowed, but not recommended"
+It is possible to use any language, including cyrillic letters or even hieroglyphs, like this:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 let имя = '...';
@@ -194,10 +275,17 @@ let 我 = '...';
 技术上讲，完全没有错误，这样的命名是完全允许的，但是有一个国际传统：在变量命名中使用英文。哪怕我们正在写一个很小的脚本，它也有可能有很长的生命周期。某个时候，来自其他国家的人可能会阅读它。
 ````
 
+<<<<<<< HEAD
 ````warn header="保留字"
 有一长串的保留字无法用作变量命名，因为它们被语言本身采用了。
 
 比如，单词 `let`、`class`、`return`、`function` 被保留。
+=======
+````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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 下面的代码将会抛出一个语法错误：
 
@@ -209,37 +297,56 @@ let return = 5; // 同样，不能使用 "return"，错误！
 
 ````warn header="未采用 `use strict` 下的赋值"
 
+<<<<<<< HEAD
 一般，需要在使用一个变量前定义它。但是在旧时代，可以简单地赋值来创建一个变量，而不需要 `let`。如果不使用 `use strict`，这仍然正常工作，这种行为是为了保持与旧脚本的兼容。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run no-strict
 // 注意：这个例子中没有 "use strict"
 
+<<<<<<< HEAD
 num = 5; // 如果变量 "num" 不存在，就会被创建
+=======
+num = 5; // the variable "num" is created if it didn't exist
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 alert(num); // 5
 ```
 
+<<<<<<< HEAD
 这是个糟糕的做法，严格模式下会抛出错误。
+=======
+This is a bad practice and would cause an error in strict mode:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
-```js run untrusted
+```js
 "use strict";
 
 *!*
 num = 5; // error: num is not defined
 */!*
 ```
-
 ````
 
 ## 常量
 
+<<<<<<< HEAD
 声明一个常数（不变）变量，可以使用 `const` 而非 `let`：
+=======
+To declare a constant (unchanging) variable, use `const` instead of `let`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 const myBirthday = '18.04.1982';
 ```
 
+<<<<<<< HEAD
 使用 `const` 声明的变量称为“常量”。它们不能被修改，尝试这样做就会造成错误：
+=======
+Variables declared using `const` are called "constants". They cannot be changed. An attempt to do so would cause an error:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 const myBirthday = '18.04.1982';
@@ -247,7 +354,11 @@ const myBirthday = '18.04.1982';
 myBirthday = '01.01.2001'; // 错误，不能对常量重新赋值
 ```
 
+<<<<<<< HEAD
 当程序员能确定这个变量永远不会改变的时候，就可以使用 `const` 来确保这种行为，并且清楚地向别人传递这一事实。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 
 ### 大写形式的常数
@@ -256,7 +367,11 @@ myBirthday = '01.01.2001'; // 错误，不能对常量重新赋值
 
 这些常量使用大写和下划线命名。
 
+<<<<<<< HEAD
 就像这样：
+=======
+For instance, let's make constants for colors in so-called "web" (hexadecimal) format:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 const COLOR_RED = "#F00";
@@ -271,6 +386,7 @@ alert(color); // #FF7F00
 
 好处:
 
+<<<<<<< HEAD
 - `COLOR_ORANGE` 比 `"#FF7F00"` 更容易记忆。
 - 比起 `COLOR_ORANGE` 而言，`"#FF7F00"` 更容易输错。
 - 阅读代码时，`COLOR_ORANGE` 比 `#FF7F00` 更有含义。
@@ -278,13 +394,26 @@ alert(color); // #FF7F00
 什么时候该为常量使用大写命名，什么时候常规命名。让我们弄清楚一点：
 
 作为一个常数，意味着值永远不变。但是有些常量在执行之前就已知了（比如红色的十六进制值），还有些在执行期间实时“计算”，赋值之后才不会改变。
+=======
+- `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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如：
 ```js
 const pageLoadTime = /* time taken by a webpage to load */;
 ```
 
+<<<<<<< HEAD
 `pageLoadTime` 的值在页面加载之前是未知的，所以采用常规命名。但是它仍然是个常量，因为赋值之后不会改变。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 换句话说，大写命名的常量仅用作“硬编码”值的别名。
 
@@ -292,6 +421,7 @@ const pageLoadTime = /* time taken by a webpage to load */;
 
 谈到变量，还有一件非常重要的事。
 
+<<<<<<< HEAD
 请合理地命名变量。如果有需要，花时间思考一下。
 
 变量命名是编程过程中最重要和最复杂的技能之一。快速地浏览变量的命名就知道代码是一个初学者还是有经验的开发者书写的。
@@ -299,9 +429,19 @@ const pageLoadTime = /* time taken by a webpage to load */;
 在一个现实的项目中，大多数的时间用来修改和扩展现有的代码库，而不是从头开始写一些完全独立的代码。当一段时间后，我们做完其他事情，重返我们的代码，找到命名良好的信息要容易得多。换句话说，变量要有个好名字。
 
 声明变量之前，多花点时间思考它的良好命名。你会受益良多。
+=======
+A variable name should have a clean, obvious meaning, describe the data that it stores.
+
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 一些很好遵循的规则是：
 
+<<<<<<< HEAD
 - 使用人类可读的命名，比如 `userName` 或者 `shoppingCart`。
 - 诸如 `a`、`b`、`c` 的缩写和短名称，离它们远点，除非你真的知道你在干什么。
 - 变量名要能够准确描述变量并且足够简洁。不好的例子就是 `data` 和 `value`，这样的名称等于什么都没说。如果能够非常明显地从上下文知道数据和值所表达的含义，这样使用它们也是可以的。
@@ -315,18 +455,45 @@ const pageLoadTime = /* time taken by a webpage to load */;
 结果是，这个变量就像是被扔进不同东西盒子，而没有改变它的贴纸。现在里面是什么？谁知道呢。我们需要靠近一点，然后检查它。
 
 这样的程序员节省了一点变量声明的时间，但却在调试代码的时候损失数十倍。
+=======
+- 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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 额外声明一个变量绝对是利大于弊的。
 
+<<<<<<< HEAD
 目前的 JavaScript 压缩器和浏览器都很够很好地优化代码，所以不会产生性能问题。为不同的值使用不同的变量可以帮助引擎进行优化。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ## 总结
 
+<<<<<<< HEAD
 我们可以声明变量来存储数据。可以通过使用 `var`、`let` 或者 `const` 来完成。
+=======
+We can declare variables to store data by using the `var`, `let`, or `const` keywords.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - `let` -- 新时代的变量声明方式。Chrome（V8）中代码必须开启严格模式以使用 `let`。
 - `var` -- 旧时代的变量声明方式。一般情况下，我们不会使用它。但是，我们会在 <info:var> 章节介绍 `var` 和 `let` 的微妙差别，以防你需要它们。
 - `const` -- 类似于`let`，但是变量的值无法被修改。
 
+<<<<<<< HEAD
 变量应当以一种容易理解变量内部是什么的方式进行命名。
+=======
+Variables should be named in a way that allows us to easily understand what's inside them.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 6dd3803d97..9135e930a0 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 f57b04ab16..c9569e6386 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 ab532d91d3..6d24825561 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 c9c37f034e..845f344084 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 e4041b1b8a..f96d1b541d 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 @@
 # 数据类型
 
+<<<<<<< HEAD
 JavaScript 中的变量可以保存任何数据。变量在前一刻可以是个字符串，然后又收到一个数值：
+=======
+A variable in JavaScript can contain any data. A variable can at one moment be a string and at another be a number:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 // 没有错误
@@ -10,7 +14,11 @@ message = 123456;
 
 允许这种操作的编程语言称为“动态类型”（dynamically typed）的编程语言，意思是，拥有数据类型，但是变量并不限于数据类型中的任何一个。
 
+<<<<<<< HEAD
 在 JavaScript 中有七种基本数据类型。这一章我们会学习基本知识，下一章我们会详细介绍它们。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## number 类型
 
@@ -19,11 +27,19 @@ let n = 123;
 n = 12.345;
 ```
 
+<<<<<<< HEAD
 *number* 类型用于整数和浮点数。
 
 数字有很多操作，比如，乘法 `*`、除法 `/`、加法 `+`、减法 `-` 等等。
 
 除了常规的数字，还包括所谓的“特殊数值”也属于这种类型：`Infinity`、`-Infinity` 和 `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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - `Infinity` 代表数学概念中的[无穷大](https://en.wikipedia.org/wiki/Infinity) ∞。是一个比任何数字都大的特殊值。
 
@@ -33,7 +49,11 @@ n = 12.345;
     alert( 1 / 0 ); // Infinity
     ```
 
+<<<<<<< HEAD
     或者在代码中直接提及它。
+=======
+    Or just reference it directly:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js run
     alert( Infinity ); // Infinity
@@ -44,12 +64,17 @@ n = 12.345;
     alert( "not a number" / 2 ); // NaN, 这样的除法是错误的
     ```
 
+<<<<<<< HEAD
     `NaN` 是粘性的。任何对 `NaN` 的进一步操作都会给出 `NaN`：
+=======
+    `NaN` is sticky. Any further operation on `NaN` returns `NaN`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js run
     alert( "not a number" / 2 + 5 ); // NaN
     ```
 
+<<<<<<< HEAD
     所以，如果在数学表达式中有一个 `NaN`，会被传播到最终结果。
 
 ```smart header="数学运算是安全的"
@@ -59,12 +84,27 @@ n = 12.345;
 ```
 
 特殊的数值属于 **number** 类型。当然，对这个词的一般认识是，它们并不是数字。
+=======
+    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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 我们将在章节 <info:number> 了解更多有关使用数字的内容。
 
 ## string 类型
 
+<<<<<<< HEAD
 JavaScript 中的字符串必须被包含在引号里面。
+=======
+A string in JavaScript must be surrounded by quotes.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 let str = "Hello";
@@ -92,9 +132,15 @@ alert( `Hello, *!*${name}*/!*!` ); // Hello, John!
 alert( `the result is *!*${1 + 2}*/!*` ); // 结果是 3
 ```
 
+<<<<<<< HEAD
 `${…}` 内的表达式会被计算，结果成为字符串的一部分。可以在 `${…}` 内放置任何东西：诸如 `name` 的变量，或者诸如 `1 + 2` 的算数表达式，或者其他一些更复杂的。
 
 需要注意的是，这仅仅在反引号内有效，其他引号不允许这种嵌入。
+=======
+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!
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```js run
 alert( "the result is ${1 + 2}" ); // 结果是 ${1 + 2} (双引号什么也不做)
 ```
@@ -128,31 +174,57 @@ let isGreater = 4 > 1;
 alert( isGreater ); // true (比较的结果是 "yes")
 ```
 
+<<<<<<< HEAD
 更详细的内容将会在章节 <info:logical-operators> 进行介绍。
+=======
+We'll cover booleans more deeply in the chapter <info:logical-operators>.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## "null" 值
 
+<<<<<<< HEAD
 特殊的 `null` 值不属于上述任何一种类型。
 
 它构成一个独立的类型，只包含 `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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 let age = null;
 ```
 
+<<<<<<< HEAD
 相比较于其他语言，JavaScript 中的 `null` 不是一个“对不存在对象的引用”或者 “null 指针”。
 
 仅仅是一个含义为“无”、“空”或“值未知”的特殊值。
 
 上面的代码表示，由于某些原因，`age` 是未知的。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## "undefined" 值
 
+<<<<<<< HEAD
 特殊值和 `null` 一样，自成类型。
+=======
+The special value `undefined` also stands apart. It makes a type of its own, just like `null`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `undefined` 的含义是 `未被赋值`。
 
+<<<<<<< HEAD
 如果变量被声明，而未被赋值，那么它的值就是 `undefined`：
+=======
+If a variable is declared, but not assigned, then its value is `undefined`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let x;
@@ -170,26 +242,47 @@ x = undefined;
 alert(x); // "undefined"
 ```
 
+<<<<<<< HEAD
 ...但是不建议这样做。通常，使用使用 `null` 将一个“空”或者“未知”的值写入变量中，`undefined` 仅仅用于检验，以查看变量是否被赋值或者其他类似的操作。
+=======
+...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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## object 类型和 symbol 类型
 
 `object` 类型是特殊的类型。
 
+<<<<<<< HEAD
 其他所有的类型都称为“原生类型”，因为它们的值只包含一个单独的东西（字符串、数字或者其他）。相反，对象用于储存数据集合和更复杂的实体。在充分了解原生类型之后，我们会在章节 <info:object> 介绍对象。
 
 `symbol` 类型用于创建对象的唯一标识符。为了学习的完整性，我们在这里提到 `symbol` 类型，但最好在学完对象之后再学习它。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## typeof 运算符 [#type-typeof]
 
+<<<<<<< HEAD
 `typeof` 运算符返回参数的类型。当我们想要分别处理不同类型值的时候，或者简单地进行检验，就很有用。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 它支持两种语法形式：
 
+<<<<<<< HEAD
 1. 作为运算符：`typeof x`。
 2. 函数形式：`typeof(x)`。
 
 换言之，有括号和没有括号，结果是一样的。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 对 `typeof x` 的调用返回数据类型的字符串。
 
@@ -217,16 +310,25 @@ typeof alert // "function"  (3)
 */!*
 ```
 
+<<<<<<< HEAD
 最后三行可能需要额外的说明：
 
 1. `Math` 是一个提供数学运算的内建对象。我们会在章节 <info:number> 学习它。此处作为一个对象的例子。
 2. `typeof null` 的结果是 `"object"`。这是不对的。这是官方在 `typeof` 方面承认的错误，只是为了兼容性而保留。当然，`null` 不是一个对象。它有自己的类型，是一个特殊值。再次强调，这是语言中的一个错误。
 3. `typeof alert` 的结果是 `"function"`，因为 `alert` 在语言中是一个函数。我们会在下一章学习函数，那时我们会了解到，在语言中没有一个特别的 "function" 类型。函数隶属于 object 类型。但是 `typeof` 会对函数区分对待。这不正确，但在实践中非常方便。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 总结
 
 JavaScript 中有七种基本的类型。
 
+<<<<<<< HEAD
 - `number` 用于任何类型的数字：整数或者浮点数。
 - `string` 用于字符串。一个字符串可以包含一个或多个字符，所以没有单独的单字符类型。
 - `boolean` 用于 `true` 和 `false`。
@@ -234,11 +336,24 @@ JavaScript 中有七种基本的类型。
 - `undefined` 用于未定义的值 —— 只有一个 `undefined` 值的独立类型。
 - `object` 用于更复杂的数据结构。
 - `symbol` 用于唯一的标识符。
+=======
+There are 7 basic data types in JavaScript.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `typeof` 运算符可以查看变量的类型。
 
+<<<<<<< HEAD
 - 两种形式：`typeof x` 或者 `typeof(x)`。
 - 返回的类型的字符串，比如 `"string"`。
 - `null` 返回 `"object"` —— 这是语言中的一个错误，实际上它并不是一个对象。
 
 在接下来的章节中，我们将重点介绍原生类型值，一旦掌握了，我们将继续讨论对象。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 bbb50e78bb..f73833c371 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. 字符串的加法 `"" + 1` 会将 `1` 转换为一个字符串：`"" + 1 = "1"`，然后我们得到了 `"1" + 0`，再次应用同样的规则。
 2. 减法 `-` （就像大多数数学操作那样）只能用于数字，它会将空字符串 `""` 转换为 `0`。
 3. `null` 经过数字化转换之后会变为 `0`。
 4. `undefined` 经过数字化转换之后会变为 `NaN`。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 a44227ce4f..a14e966630 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 cf4b446a3d..5c5a7c1f24 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 @@
 # 类型转换
 
+<<<<<<< HEAD
 大多数情况下，运算符和函数会自动转换将值转换为正确的类型。称之为“类型转换”。
+=======
+Most of the time, operators and functions automatically convert the values given to them to the right type. 
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 比如，`alert` 会自动将任何值转换为字符串。算术运算符会将值转换为数字。
 
+<<<<<<< HEAD
 还有些例子，需要显式进行类型转换，以得到正确的结果。
 
 ```smart header="对象还未纳入讨论中"
 本章并不会讨论 object 类型。先学习原始类型，之后我们会学习 object 类型。对象的类型转换在章节 <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>.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ## ToString
@@ -16,7 +27,11 @@
 
 比如，`alert(value)` 将 `value` 转换为 string 类型，然后显示这个值。
 
+<<<<<<< HEAD
 也可以显式地调用 `String(value)` 来达到这一目的：
+=======
+We can also call the `String(value)` function to convert a value to a string:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let value = true;
@@ -28,7 +43,11 @@ alert(typeof value); // string
 */!*
 ```
 
+<<<<<<< HEAD
 转换为 string 类型的值往往是可预见的。`false` 变成 `"false"`，`null` 变成 `"null"` 等。
+=======
+String conversion is mostly obvious. A `false` becomes `"false"`, `null` becomes `"null"`, etc.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## ToNumber
 
@@ -40,7 +59,11 @@ alert(typeof value); // string
 alert( "6" / "2" ); // 3, strings are converted to numbers
 ```
 
+<<<<<<< HEAD
 也可以使用 `Number(value)` 显式地将这个值转换为 number 类型。
+=======
+We can use the `Number(value)` function to explicitly convert a `value` to a number:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let str = "123";
@@ -51,9 +74,15 @@ let num = Number(str); // 变成 number 类型 123
 alert(typeof num); // number
 ```
 
+<<<<<<< HEAD
 当从 string 类型源读取值时，比如一个文本表单，但是我们期待数字输入，就经常进行显式转换。
 
 如果字符串不是一个有效的数字，转换的结果会是 `NaN`，例如：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let age = Number("an arbitrary string instead of a number");
@@ -67,8 +96,13 @@ number 类型转换规则：
 |-------|-------------|
 |`undefined`|`NaN`|
 |`null`|`0`|
+<<<<<<< HEAD
 |<code>true&nbsp;和&nbsp;false</code> | `1` and `0` |
 | `string` | 字符串开始和末尾的空白会被移除，剩下的如果是空字符串，结果为 `0`，否则 —— 从字符串中读出数字。错误返回 `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`. |
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如：
 
@@ -79,31 +113,53 @@ alert( Number(true) );        // 1
 alert( Number(false) );       // 0
 ```
 
+<<<<<<< HEAD
 请注意 `null` 和 `undefined` 有点不同。`null` 变成数字 `0`，`undefined` 变成 `NaN`。
 
 ````smart header="加号'+' 连接字符串"
 几乎所有的算术运算符都将值转换为数字，加号 `+` 是个例外。如果其中一个运算元是字符串，则另一个也会转换为字符串。
 
 然后，连接两者：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 alert( 1 + '2' ); // '12' (字符串在加号右边)
 alert( '1' + 2 ); // '12' (字符串在加号左边)
 ```
 
+<<<<<<< HEAD
 这仅仅发生在其中一方为字符串（译者注：或者双方都为字符串）的情况下。其他情况下会被转换为数字。
+=======
+This only happens when at least one of the arguments is a string. Otherwise, values are converted to numbers.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ````
 
 ## ToBoolean
 
 转换为 boolean 类型是最为简单的一个。
 
+<<<<<<< HEAD
 逻辑操作或显式调用 `Boolean(value)` 会触发 boolean 类型转换。
+=======
+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)`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 转换规则如下：
 
+<<<<<<< HEAD
 - 假值，比如 `0`、空的字符串、`null`、`undefined` 和 `NaN` 变成 `false`。
 - 其他值变成 `true`。
+=======
+- Values that are intuitively "empty", like `0`, an empty string, `null`, `undefined`, and `NaN`, become `false`.
+- Other values become `true`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 比如：
 
@@ -115,8 +171,13 @@ alert( Boolean("hello") ); // true
 alert( Boolean("") ); // false
 ```
 
+<<<<<<< HEAD
 ````warn header="请注意: 包含 0 的字符串 `\"0\"` 是 `true`"
 一些编程语言（比如 PHP）视 `"0"` 为 `false`。但在 JavaScript 中，非空的字符串总是 `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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 alert( Boolean("0") ); // true
@@ -127,11 +188,19 @@ alert( Boolean(" ") ); // 空白, 也是 true (任何非空字符串是 true)
 
 ## 总结
 
+<<<<<<< HEAD
 有三种常用的类型转换：转换为 string 类型、转换为 number 类型和转换为 boolean 类型。
 
 **`ToString`** —— 输出内容时 `ToString` 发生转换，或通过 `String(value)` 进行显式转换。原始类型值的 string 类型转换通常是可预见的。
 
 **`ToNumber`** -- 进行算术操作时发生 `ToNumber` 转换，或通过 `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)`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `ToNumber` 转换遵循以下规则：
 
@@ -142,7 +211,11 @@ alert( Boolean(" ") ); // 空白, 也是 true (任何非空字符串是 true)
 |<code>true&nbsp;/&nbsp;false</code> | `1 / 0` |
 | `string` | 字符串“按原样读取”，两端的空白被忽略。空字符串变成 `0`。出错变成 `NaN`。 |
 
+<<<<<<< HEAD
 **`ToBoolean`** -- 进行逻辑操作时发生 `ToBoolean` 转换。或通过 `Boolean(value)` 进行显式转换。
+=======
+**`ToBoolean`** -- Occurs in logical operations. Can be performed with `Boolean(value)`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `ToBoolean` 遵循以下规则：
 
@@ -157,4 +230,8 @@ alert( Boolean(" ") ); // 空白, 也是 true (任何非空字符串是 true)
 - `undefined` 进行 `ToNumber` 时变成 `NaN`，而非 `0`。
 - `"0"` 和只有空格的字符串(比如：`"   "` )在进行 `ToBoolean` 变成 `true`。
 
+<<<<<<< HEAD
 对象的转换并未在此提及，我们会在章节 <info:object-toprimitive> 介绍，随后我们会学习 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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/1-js/02-first-steps/07-operators/article.md b/1-js/02-first-steps/07-operators/article.md
index 9520a857f3..753f385aea 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 @@
 # 运算符
 
+<<<<<<< HEAD
 从入学开始，我们就熟悉许多运算符，比如说加号 `+`、乘号 `*`、减号 `-` 等。
 
 这个章节，我们将关注一些在学校数学课程中没有涵盖的运算符。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 术语：「一元运算符」、「二元运算符」、「运算元」
 
+<<<<<<< HEAD
 首先，我们简单浏览一下常用术语。
 
 - **运算元** —— 运算符应用的对象。比如说乘法运算 `5 * 2`，有两个运算元：左运算元 `5` 和右运算元 `2`。有时候人们也称其为「参数」。
 - 如果一个运算符对应的只有一个运算元，那么它是 **一元运算符**。比如说一元运算符 `-`，它的作用是对数字取反：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js run
     let x = 1;
@@ -19,13 +32,18 @@
     */!*
     alert( x ); // -1，一元负号运算符生效
     ```
+<<<<<<< HEAD
 - 如果一个运算符拥有两个运算元，那么它是 **二元运算符**。减号还存在二元运算符形式：
+=======
+- An operator is *binary* if it has two operands. The same minus exists in binary form as well:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js run no-beautify
     let x = 1, y = 3;
     alert( y - x ); // 2，二元运算符减号做减运算
     ```
 
+<<<<<<< HEAD
     正式说明：我们正在讨论两种不同的运算符：一元负号运算符（单一运算元，改变正负号）和二元运算符减号（两个运算元，做减法）。
 
 ## 字符串连接功能，二元运算符 +
@@ -35,13 +53,28 @@
 通常，加号 `+` 用来求和。
 
 但是如果加号 `+` 应用于字符串，它将合并（连接）各个字符串：
+=======
+    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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 let s = "my" + "string";
 alert(s); // mystring
 ```
 
+<<<<<<< HEAD
 注意：只要任一运算元是字符串，那么其它运算元也将转化为字符串。
+=======
+Note that if one of the operands is a string, the other one is converted to a string too.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 举个例子：
 
@@ -50,7 +83,11 @@ alert( '1' + 2 ); // "12"
 alert( 2 + '1' ); // "21"
 ```
 
+<<<<<<< HEAD
 可以看出，字符串在前和在后并不影响这个规则。简单来说：如果任一运算元是字符串，那么其它运算元将被转化为字符串。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 但是，请注意：运算符的运算方向是由左至右。如果是两个数字，后面再跟一个字符串，那么两个数字会先相加，再转化为字符串：
 
@@ -59,7 +96,11 @@ alert( 2 + '1' ); // "21"
 alert(2 + 2 + '1' ); // "41" 而不是 "221"
 ```
 
+<<<<<<< HEAD
 字符串连接和转化是加号 `+` 的一个特性。其它的数学运算符都只对数字有效。通常，他们会转化运算元为数字。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 举个例子：减号和除号：
 
@@ -70,9 +111,15 @@ alert( '6' / '2' ); // 3
 
 ## 数字转化功能，一元运算符 +
 
+<<<<<<< HEAD
 加号 `+` 有两种形式。一种是以上讨论的二元运算符，还有一种是一元运算符。
 
 一元运算符加号，或者说，加号 `+` 应用于单个值，对数字没有作用。但是如果运算元是非数字，它会将其转化为数字。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 比如：
 
@@ -91,9 +138,15 @@ alert( +"" );   // 0
 */!*
 ```
 
+<<<<<<< HEAD
 它的效果和 `Number(...)` 相同，但是更加简短。
 
 将字符串转化为数字的需求经常出现。比如，如果我们正在从 HTML 表单中取值，通常得到的都是字符串。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如果我们想对他们求和，该怎么办？
 
@@ -106,7 +159,11 @@ let oranges = "3";
 alert( apples + oranges ); // "23"，二元运算符连接成字符串
 ```
 
+<<<<<<< HEAD
 如果我们想把它们当做数字对待，我们需要转化它们，然后再求和：
+=======
+If we want to treat them as numbers, we need to convert and then sum them:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let apples = "2";
@@ -121,6 +178,7 @@ alert( +apples + +oranges ); // 5
 // alert( Number(apples) + Number(oranges) ); // 5
 ```
 
+<<<<<<< HEAD
 从一个数学家的视角来看，大量的加号可能很奇怪。但是从一个程序员的视角，没什么好奇怪的：一元运算符首先起作用，他们将字符串转为数字，然后二元运算符加号对它们求和。
 
 为什么一元运算符先于二元运算符作用于运算元？接下去我们将讨论到，这是由于它们拥有更高的 **优先级**。
@@ -136,6 +194,23 @@ alert( +apples + +oranges ); // 5
 在 JavaScript 中有众多运算符。每个运算符都有对应的优先级数字。数字越大，越先执行。如果优先级相同，那么执行顺序由左至右。
 
 摘抄自 [优先级表](https://developer.mozilla.org/en/JavaScript/Reference/operators/operator_precedence) （你不必记住它，只要知道一元运算符优先级高于二元运算符）：
+=======
+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):
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 | Precedence | Name | Sign |
 |------------|------|------|
@@ -150,13 +225,21 @@ alert( +apples + +oranges ); // 5
 | 3 | assignment | `=` |
 | ... | ... | ... |
 
+<<<<<<< HEAD
 我们可以看到，「一元运算符 加号」 拥有优先级 `16`，高于「二元运算符 加法」的优先级 `13`。这也是为什么表达式 `"+apples + +oranges"` 一元加号先生效，然后才是二元加法。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 赋值运算符
 
 我们知道赋值符号 `=` 也是一个运算符。在优先级表中显示它的优先级非常低，只有 `3`。
 
+<<<<<<< HEAD
 这也是为什么，当我们赋值时，比如 `x = 2 * 2 + 1`，所有的计算先执行，然后 `=` 执行，将计算结果存储到 `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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 let x = 2 * 2 + 1;
@@ -178,14 +261,25 @@ alert( b ); // 4
 alert( c ); // 4
 ```
 
+<<<<<<< HEAD
 链式赋值由右到左执行。首先最右侧表达式 `2 + 2` 执行，然后将结果赋值给左侧：`c`、`b`、`a`。最后，所有的变量都共享一个值。
 
 ````smart header="赋值运算符 `\"=\"` 返回一个值"
 每个运算符都有一个返回值。对于以加号 `+` 或者乘号 `*` 为例的大部分运算符而言，这一点很显然。对于赋值运算符而言，这一点同样适用。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 语句 `x = value` 把 `value` 的值写入 `x` *然后返回 x*。
 
+<<<<<<< HEAD
 下面是一个在复杂语句中使用赋值的例子：
+=======
+Here's a demo that uses an assignment as part of a more complex expression:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let a = 1;
@@ -201,12 +295,20 @@ alert( c ); // 0
 
 以上这个例子，`(a = b + 1)` 的结果是赋值给 `a` 的值（即是 3）。然后该值用于与 `3` 相减。
 
+<<<<<<< HEAD
 有趣的代码，不是吗？我们应该理解它的原理，因为我们有时会在第三方库中见到这样的写法，我们自己不应该这样写。这样的小技巧让代码变得不整洁，阅读性也变差。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ````
 
 ## 求余运算符 %
 
+<<<<<<< HEAD
 运算符 `%` 尽管看上去是个百分号，但和百分数没有什么关系。
+=======
+The remainder operator `%`, despite its appearance, is not related to percents.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `a % b` 的结果是 `a` 除以 `b` 的余数。
 
@@ -232,7 +334,13 @@ alert( 2 ** 3 ); // 8  (2 * 2 * 2)
 alert( 2 ** 4 ); // 16 (2 * 2 * 2 * 2)
 ```
 
+<<<<<<< HEAD
 这个运算符对于 `a` 和 `b` 是非整数的情况依然适用，举个例子：
+=======
+The operator works for non-integer numbers as well.
+
+For instance:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 alert( 4 ** (1/2) ); // 2 (1 / 2 幂相当于开方，这是数学常识)
@@ -245,7 +353,11 @@ alert( 8 ** (1/3) ); // 2 (1 / 3 幂相当于开三次方)
 
 对一个数进行加操作或者减操作是最常见的数值运算符。
 
+<<<<<<< HEAD
 因此，围绕着它们，有一些特殊的运算符：
+=======
+So, there are special operators for it:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - **自相加** `++` 将变量与1相加：
 
@@ -263,6 +375,7 @@ alert( 8 ** (1/3) ); // 2 (1 / 3 幂相当于开三次方)
     ```
 
 ```warn
+<<<<<<< HEAD
 自相加/自相减只能应用于变量。尝试将其应用于数值（比如 `5++`）会报错。
 ```
 
@@ -272,12 +385,29 @@ alert( 8 ** (1/3) ); // 2 (1 / 3 幂相当于开三次方)
 - 当运算符在变量前，被称为「前置形式」：`++counter`。
 
 两者都做同一件事：将变量 `counter` 与 `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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 那么，有什么区别呢？有，但只有当我们需要 `++/--` 的返回值时才能看到区别。
 
+<<<<<<< HEAD
 让我们来明确这一点。我们知道，所有的运算符都有返回值。自相加/自相减也不例外。前置形式返回一个新的值，但后置返回原来的值（做加法/减法之前的值）。
 
 为了直观看到区别，看下面的例子：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let counter = 1;
@@ -286,9 +416,15 @@ let a = ++counter; // (*)
 alert(a); // *!*2*/!*
 ```
 
+<<<<<<< HEAD
 `(*)` 所在的行是前置形式 `++counter`，对 `counter` 做自相加，返回的是新的值 `2`。因此 `alert` 显示的是 `2`。
 
 下面让我们看看后置形式：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let counter = 1;
@@ -297,11 +433,19 @@ let a = counter++; // (*) 将 ++counter 改为 counter++
 alert(a); // *!*1*/!*
 ```
 
+<<<<<<< HEAD
 `(*)` 所在的行是后置形式 `counter++`，它同样对 `counter` 做加法，但是返回的是**旧值**（做加法之前）。因此 `alert` 显示的是 `1`。
+=======
+In the line `(*)`, the *postfix* form `counter++` also increments `counter` but returns the *old* value (prior to increment). So, the `alert` shows `1`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 总结：
 
+<<<<<<< HEAD
 - 如果自相加/自相减的值不会被使用，那么两者形式没有区别：
+=======
+- If the result of increment/decrement is not used, there is no difference in which form to use:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js run
     let counter = 0;
@@ -309,21 +453,34 @@ alert(a); // *!*1*/!*
     ++counter;
     alert( counter ); // 2，以上两行作用相同
     ```
+<<<<<<< HEAD
 - 如果我们想要对变量自相加 **并且** 立刻使用值，那么我们需要使用前置形式：
+=======
+- If we'd like to increase a value *and* immediately use the result of the operator, we need the prefix form:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js run
     let counter = 0;
     alert( ++counter ); // 1
     ```
+<<<<<<< HEAD
 - 如果我们想要使用之前的值，那么我们需要使用后置形式：
+=======
+- If we'd like to increment a value but use its previous value, we need the postfix form:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js run
     let counter = 0;
     alert( counter++ ); // 0
     ```
 
+<<<<<<< HEAD
 ````smart header="自相加/自相减和其它运算符的对比"
 `++/--` 运算符同样可以在表达式内部使用。它们的优先级比绝大部分的运算符要高。
+=======
+````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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 举个例子：
 
@@ -339,11 +496,19 @@ let counter = 1;
 alert( 2 * counter++ ); // 2，因为 counter++ 返回的是「旧值」
 ```
 
+<<<<<<< HEAD
 尽管从技术层面上来说可行，但是这样的写法会减少代码的可阅读性。在一行上做多个操作 —— 这样并不好。
 
 当阅读代码时，快速的视觉「纵向」扫描会很容易漏掉 `counter++`，知道那个变量自相加并不简单。
 
 「一行一个操作」模式是更好的选择：
+=======
+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":
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let counter = 1;
@@ -368,11 +533,19 @@ counter++;
 - 右移 ( `>>` )
 - 无符号右移 ( `>>>` )
 
+<<<<<<< HEAD
 这些操作使用得非常少。为了理解它们，我们需要探讨底层的数字表达形式，现在不是做这个的最好时机。尤其是我们现在不会立刻使用它。如果你感兴趣，可以阅读 MDN 中的[位运算符](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators)相关文章。当有实际需求出现的时候再去阅读是更明智的选择。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 修改并替换
 
+<<<<<<< HEAD
 我们经常需要对一个变量进行操作，然后把新的结果存储给变量。
+=======
+We often need to apply an operator to a variable and store the new result in that same variable.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 举个例子：
 
@@ -382,7 +555,11 @@ n = n + 5;
 n = n * 2;
 ```
 
+<<<<<<< HEAD
 这个操作可以使用运算符 `+=` 和 `*=` 来简化：
+=======
+This notation can be shortened using the operators `+=` and `*=`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let n = 2;
@@ -392,7 +569,11 @@ n *= 2; // now n = 14 (同n = n * 2)
 alert( n ); // 14
 ```
 
+<<<<<<< HEAD
 简短的「修改并替换」 运算符对所有的运算符都有效，以及位运算符：`/=`、`-=`等等。
+=======
+Short "modify-and-assign" operators exist for all arithmetical and bitwise operators: `/=`, `-=`, etc.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这些运算符和正常的赋值运算符拥有相同的优先级，因此它们会在其它运算之后运行：
 
@@ -406,9 +587,15 @@ alert( n ); // 16 （右侧计算首先进行，和 n *= 8 相同）
 
 ## 逗号运算符
 
+<<<<<<< HEAD
 逗号运算符 `,` 是最少见最不常使用的运算符之一。有时候它会被用来写更简短的代码，因此为了能够理解代码，我们需要了解它。
 
 逗号运算符能让我们处理多个语句，使用 `,` 将它们分开。每个语句都运行了，但是只有最后的语句结果会被返回。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 举个例子：
 
@@ -420,17 +607,30 @@ let a = (1 + 2, 3 + 4);
 alert( a ); // 7 (3 + 4 的结果)
 ```
 
+<<<<<<< HEAD
 这里，第一个语句 `1 + 2` 运行了，但是它的结果被丢弃了，然后 `3 + 4` 运行，计算结果被返回。
+=======
+Here, the first expression `1 + 2` is evaluated and its result is thrown away. Then, `3 + 4` is evaluated and returned as the result.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```smart header="逗号运算符的优先级非常低"
 请注意逗号运算符的优先级非常低，比 `=` 还要低，因此上面你的例子中圆括号非常重要。
 
+<<<<<<< HEAD
 如果没有圆括号：`a = 1 + 2, 3 + 4` 会先执行 `+`，将数值相加得到 `a = 3, 7`，然后赋值运算符 `=` 执行, 'a = 3'，然后逗号之后的数值 `7` 不会再执行，它被忽略掉了。
 ```
 
 为什么我们需要这样一个运算符，它只返回最后一个值呢？
 
 有时候，人们会使用它把几个操作放在一行上来进行复杂的运算。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 举个例子：
 
@@ -441,4 +641,8 @@ for (*!*a = 1, b = 3, c = a * b*/!*; a < 10; a++) {
 }
 ```
 
+<<<<<<< HEAD
 这样的技巧在许多 JavaScript 框架中都有使用，这也是为什么我们提到它。但是通常它并不能提升代码的可阅读性，使用它之前，我们要想清楚。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/1-js/02-first-steps/08-comparison/1-comparison-questions/task.md b/1-js/02-first-steps/08-comparison/1-comparison-questions/task.md
index 2c4446fefe..1f95ca14fa 100644
--- a/1-js/02-first-steps/08-comparison/1-comparison-questions/task.md
+++ b/1-js/02-first-steps/08-comparison/1-comparison-questions/task.md
@@ -4,7 +4,11 @@ importance: 5
 
 # 值的比较
 
+<<<<<<< HEAD
 以下表达式的执行结果是？
+=======
+What will be the result for these expressions?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js no-beautify
 5 > 4
diff --git a/1-js/02-first-steps/08-comparison/article.md b/1-js/02-first-steps/08-comparison/article.md
index 9389c1e450..2c29682560 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 @@
 # 值的比较
 
+<<<<<<< HEAD
 在 JavaScript 中，我们可以使用一些熟知的数学符号进行值的比较：
 
 - 大于 / 小于：<code>a &gt; b</code>，<code>a &lt; b</code>。
 - 大于等于 / 小于等于：<code>a &gt;= b</code>，<code>a &lt;= b</code>。
 - 检测两个值的相等写为 `a == b`（注意表达式中是两个等号 `=`，若写为单个等号 `a = b` 则表示赋值）。
 - 检测两个值的不等，在数学中使用 <code>&ne;</code> 符号，而在 JavaScript 中则通过在赋值符号前增加叹号表示：<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>.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 比较结果为 Boolean 类型
 
+<<<<<<< HEAD
 和其他操作符一样，比较操作符也会有返回值，其类型为布尔值（Boolean）。
 
 - `true` —— 表示“yes（是）”，“correct（正确）”或“the truth（真理）”。
 - `false` ——  表示“no（否）”，“wrong（错误）”或“a lie（谎言）”。
+=======
+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".
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 示例：
 
@@ -31,7 +47,11 @@ alert( result ); // true
 
 ## 字符串间的比较
 
+<<<<<<< HEAD
 在比较字符串的大小时，会使用“字典”或“词典”顺序进行判定。
+=======
+To see whether a string is greater than another, JavaScript uses the so-called "dictionary" or "lexicographical" order.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 换言之，字符串是按字符（母）逐个进行比较的。
 
@@ -45,6 +65,7 @@ alert( 'Bee' > 'Be' ); // true
 
 字符串间的比较算法非常简单：
 
+<<<<<<< HEAD
 1. 首先比较两个字符串的首位字符大小。
 2. 如果一方字符较大（或较小），则该字符串大于（或小于）另一个字符串。算法结束。
 3. 否则，两个字符串中的字符相等，继续取出各自的后一位字符进行比较。
@@ -54,20 +75,40 @@ alert( 'Bee' > 'Be' ); // true
 在上面的例子中，`'Z' > 'A'` 在算法的第 1 步就得到了返回结果。
 
 字符串 `"Glow"` 和 `"Glee"` 会按字符逐个进行比较：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 1. `G` 和 `G` 相等。
 2. `l` 和 `l` 相等。
 3. `o` 比 `e` 大，算法停止，第一个字符串大于第二个。
 
+<<<<<<< HEAD
 ```smart header="非真正的字典顺序，而是 Unicode 编码顺序"
 在上面的算法中，比较大小的逻辑与字典或电话簿中的排序很像，但也不完全相同。
 
 比如说，算法中的比较对大小写是敏感的。大写的 `"A"` 并不等于小写的 `"a"`。哪一个更大呢？实际上小写的 `"a"` 更大。至于原因嘛，这是因为在内部的编码表中（Unicode），小写字母的字符索引更大。我们会在 <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>.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ## 不同类型间的比较
 
+<<<<<<< HEAD
 当不同类型的值进行比较时，它们会首先被转为数字（number）再判定大小。
+=======
+When comparing values of different types, JavaScript converts the values to numbers.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 示例：
 
@@ -76,7 +117,13 @@ alert( '2' > 1 ); // true，字符串 '2' 会被转为数字 2
 alert( '01' == 1 ); // true，字符串 '01' 会被转为数字 1
 ```
 
+<<<<<<< HEAD
 对于布尔类型，`true` 会被转为 `1`、`false` 转为 `0`，即有：
+=======
+For boolean values, `true` becomes `1` and `false` becomes `0`. 
+
+For example:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 alert( true == 1 ); // true
@@ -101,24 +148,40 @@ alert( Boolean(b) ); // true
 alert(a == b); // true!
 ```
 
+<<<<<<< HEAD
 对于 JavaScript 而言这种现象蛮正常的，因为它会把待比较的值转为数字后再做比较（因此 `"0"` 变成了 `0` ）。若只是将一个变量转为 `Boolean`，则会使用其他的类型转换规则。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ````
 
 ## 严格相等
 
+<<<<<<< HEAD
 普通的相等性检查 `==` 存在一个问题，它不能区分出 `0` 和 `false`：
+=======
+A regular equality check `==` has a problem. It cannot differentiate `0` from `false`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 alert( 0 == false ); // true
 ```
 
+<<<<<<< HEAD
 也同样无法区分空字符串和 `false`：
+=======
+The same thing happens with an empty string:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 alert( '' == false ); // true
 ```
 
+<<<<<<< HEAD
 这是因为在比较不同类型的值时，处于相等判断符号 `==` 两侧的值会被转换为数字的原因。空字符串和 `false` 也是如此，转换后它们都等于 0。
+=======
+This happens because operands of different types are converted to numbers by the equality operator `==`. An empty string, just like `false`, becomes a zero.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如果我们需要区分 `0` 和 `false`，该怎么做呢？
 
@@ -132,19 +195,33 @@ alert( '' == false ); // true
 alert( 0 === false ); // false，比较不同类型的值
 ```
 
+<<<<<<< HEAD
 同样的，与“不相等”符号 `!=` 类似，“严格不相等”表示为 `!==`。
 
 严格相等的操作符虽然略为冗长，但是它很清楚地显示了比较的意图，降低你犯错的可能性。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 涉及 null 和 undefined 的比较
 
 让我们看看更多的边缘案例。
 
+<<<<<<< HEAD
 当使用 `null` 或 `undefined` 与其他值进行比较时，其返回结果常常出乎你的意料。
 
 
 当使用严格相等 `===` 比较二者时：
 它们是不相等的，因为它们属于不同的类型。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 alert( null === undefined ); // false
@@ -157,10 +234,17 @@ JavaScript 存在一个专属的规则，会判定它们互等。而它们就像
 alert( null == undefined ); // true
 ```
 
+<<<<<<< HEAD
 当使用数学式或其他比较方法 `< > <= >=` 时：
 `null/undefined` 的值会被转换为数字：`null` 转为 `0`，`undefined` 转为 `NaN`。
 
 下面让我们看看，这些规则会带来什么有趣的现象。同时更重要的是，我们需要从中学会如何远离这些特性带来的“陷阱”。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ### 奇怪的结果：null vs 0
 
@@ -172,15 +256,27 @@ alert( null == 0 ); // (2) false
 alert( null >= 0 ); // (3) *!*true*/!*
 ```
 
+<<<<<<< HEAD
 是的，上面的结果完全打破了你对数学的认识。在最后一行代码显示“`null` 大于等于 0”的情况下，前两行代码中一定会有一个是正确的，然而事实表明它们的结果都是 false。
 
 为什么会出现这种反常结果，这是因为相等性检测 `==` 和普通比较符 `> < >= <=` 的代码逻辑是相互独立的。进行值的比较会把 `null` 转为数字，因此它被转为了 `0`。这就是为什么（3）中 `null >= 0` 返回 true，（1）中 `null > 0` 返回 false。
 
 另一方面，`undefined` 和 `null` 在相等性检测 `==` 中不会进行任何的类型转换，它们有自己独立的比较规则，所以除了它们之间互等外不会等于任何其他的值。这就解释了为什么（2）中 `null == 0` 会返回 false。
+=======
+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.
+
+On the other hand, the equality check `==` for `undefined` and `null` is defined such that, without any conversions, they equal each other and don't equal anything else. That's why (2) `null == 0` is false.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ### “拒不合作”的 undefined
 
+<<<<<<< HEAD
 `undefined` 不应该参与任何值的比较：
+=======
+The value `undefined` shouldn't be compared to other values:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 alert( undefined > 0 ); // false (1)
@@ -188,25 +284,50 @@ alert( undefined < 0 ); // false (2)
 alert( undefined == 0 ); // false (3)
 ```
 
+<<<<<<< HEAD
 为何它看起来如此厌恶 0？无论怎么比较双方其结果总是返回 false！
 
 原因如下：
 
 - `(1)` 和 `(2)` 中返回 `false` 是因为 `undefined` 在比较中被转换为了 `NaN`，而 `NaN` 是一个特殊的数值型取值，它与任何值进行比较都会返回 `false`。
 - `(3)` 中返回 `false` 是因为这是一个相等性检测，而 `undefined` 只与 `null` 相等。
+=======
+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`, `undefined`, and no other value.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ### 规避错误
 
+<<<<<<< HEAD
 我们为何要研究以上示例？我们需要时刻记得这些古怪的规则吗？不，并不需要。虽然这些规则随着使用都会烂熟于胸，但是我们需要遵循更为可靠的方法来避免潜在的问题。
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 除了严格相等 `===` 外，其他凡是有 `undefined/null` 参与的比较，我们都需要额外 “关照”。
 
+<<<<<<< HEAD
 除非你非常清楚自己在做什么，否则永远不要使用 `>= > < <=` 去比较一个可能为 `null/undefined` 的变量。对于取值可能是 `null/undefined` 的变量，请按需要分别检查它的取值情况。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 小结
 
+<<<<<<< HEAD
 - 比较操作符始终返回逻辑值。
 - 字符串间按“词典”顺序逐字符比较大小。
 - 当待比较的值类型不同时，它们会被转为数字（不包括严格相等检测）进行比较。
 - 在非严格相等 `==` 下，`null` 和 `undefined` 相等且各自不等于任何其他的值。
 - 在使用 `>` 或 `<` 进行比较时，需要注意变量可能为 `null/undefined` 的情况。比较好的方法是单独检查变量是否等于 `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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 f2b4e3ff71..46a4bc3a86 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
@@ -1,8 +1,14 @@
 # 交互：alert、prompt、confirm
 
+<<<<<<< HEAD
 本部分旨在覆盖 JavaScript “原生”，而无需针对特定环境进行调整。
 
 但我们仍然使用浏览器作为演示环境。所以我们至少应该知道一些用户界面函数。在本章节我们将会熟悉函数 `alert`、`prompt` 和 `confirm` 的用法。
+=======
+In this part of the tutorial we cover JavaScript language "as is", without environment-specific tweaks.
+
+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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## alert
 
@@ -12,7 +18,11 @@
 alert(message);
 ```
 
+<<<<<<< HEAD
 浏览器会弹出一段信息并暂停脚本，直到用户点击了“确定”。
+=======
+This shows a message and pauses script execution until the user presses "OK".
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 举个例子：
 
@@ -20,27 +30,48 @@ alert(message);
 alert("Hello");
 ```
 
+<<<<<<< HEAD
 这个小窗口被称为 **模态窗**。"modal" 意味着用户不能与页面的其他部分进行交互，点击其他按钮等，直到他们处理完窗口。在这种情况下 - 直到他们按下“确定”。
 
 ## prompt
 
 `prompt` 函数接收两个参数：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js no-beautify
-result = prompt(title[, default]);
+result = prompt(title, [default]);
 ```
 
+<<<<<<< HEAD
 浏览器会显示一个带有文本消息的模态窗口，还有 input 框和确定/取消按钮。
 
 `title`
 : 显示给用户的文本
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `default`
 : 可选的第二个参数，指定 input 框的初始值。
 
+<<<<<<< HEAD
 用户在 prompt 对话框的 input 框输入文本并点击确定。不然就点击取消按钮或敲击 `key:Esc` 键来取消。
 
 `prompt` 返回输入的文本；如果取消输入就返回 `null`。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 举个例子：
 
@@ -50,16 +81,27 @@ let age = prompt('How old are you?', 100);
 alert(`You are ${age} years old!`); // You are 100 years old!
 ```
 
+<<<<<<< HEAD
 ````warn header="IE: always supply a `default`"
 第二个参数可选。但是如果我们不提供的话，Internet Explorer 会把 `"undefined"` 插入到 prompt。
 
 在 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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let test = prompt("Test");
 ```
 
+<<<<<<< HEAD
 所以，在 IE 中看起来很好，建议始终提供第二个参数：
+=======
+So, for prompts to look good in IE, we recommend always providing the second argument:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let test = prompt("Test", ''); // <-- for IE
@@ -74,7 +116,11 @@ let test = prompt("Test", ''); // <-- for IE
 result = confirm(question);
 ```
 
+<<<<<<< HEAD
 `confirm` 函数显示一个带有 `question` 和两个按钮的模态窗口：确定和取消。
+=======
+The function `confirm` shows a modal window with a `question` and two buttons: OK and CANCEL.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 点击确定返回 `true`，点击取消返回 `false`。
 
@@ -88,22 +134,39 @@ alert( isBoss ); // true if OK is pressed
 
 ## 总结
 
+<<<<<<< HEAD
 我们探讨了与用户交互的 3 个浏览器指定的函数：
+=======
+We covered 3 browser-specific functions to interact with visitors:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `alert`
 : 显示信息。
 
 `prompt`
+<<<<<<< HEAD
 : 显示信息要求用户输入文本。点击确定返回文本，点击取消或按下 `key:Esc` 键返回 `null`。
+=======
+: shows a message asking the user to input text. It returns the text or, if CANCEL or `key:Esc` is clicked, `null`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `confirm`
 : 显示信息等待用户点击确定或取消。点击确定返回 `true`，点击取消或 `key:Esc` 键返回 `false`。
 
+<<<<<<< HEAD
 这些方法都是模态的：它们暂停脚本执行，并且不允许用户与该页面的其余部分交互，直到消息被解除。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 上述所有方法共有两个限制：
 
+<<<<<<< HEAD
 1. 模态窗口的确切位置由浏览器决定。通常在页面中心。
 2. 窗口的确切外观还取决于浏览器。我们不能修改它。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这是简单的代价。还有其他一些方法可以显示更漂亮的窗口，并与用户进行更丰富的交互，但如果“花里胡哨”不是非常重要，这些方法也可以工作的很好。
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 8c57b18850..04fb1fb0b7 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 cbb2c611a0..08226b7903 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 8b54dc83d5..0000000000
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 92001dfe86..0000000000
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 56f50e69d1..57fe3c3e85 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 @@
 # 条件运算符：if、'?'
 
+<<<<<<< HEAD
 有时我们需要根据不同条件执行不同的操作。
 
 `if` 语句可以解决这个问题，条件运算符（三元），简称为“问号”运算符也可以解决。
+=======
+Sometimes, we need to perform different actions based on different conditions.
+
+To do that, we can use the `if` statement and the conditional operator `?`, that's also called a "question mark" operator.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## "if" 语句
 
+<<<<<<< HEAD
 `if` 语句获得一个条件，计算这个条件表达式，如果计算结果是 `true`，就会执行对应的代码。
+=======
+The `if` statement evaluates a condition and, if the condition's result is `true`, executes a block of code.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如下：
 
@@ -18,9 +28,15 @@ if (year == 2015) alert( 'You are right!' );
 */!*
 ```
 
+<<<<<<< HEAD
 在上面的例子中，条件是一个简单的相等性检查：`year == 2015`，但它可能更复杂。
 
 如果有多个语句要执行，我们必须将要执行的代码块封装在大括号内：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 if (year == 2015) {
@@ -29,16 +45,29 @@ if (year == 2015) {
 }
 ```
 
+<<<<<<< HEAD
 建议每次使用 if 语句都用大括号 `{}` 来包装代码块，即使只有一条语句也是。这样能提高代码可读性。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 布尔转换
 
+<<<<<<< HEAD
 `if（……）` 语句会计算圆括号包围的表达式的结果并将其转换为布尔类型。
+=======
+The `if (…)` statement evaluates the expression in its parentheses and converts the result to a boolean.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 让我们回顾一下 <info：type-conversions> 一章中的转换规则：
 
+<<<<<<< HEAD
 - 数字 `0`、一个空字符串 `""`、`null`、`undefined` 和 `NaN` 都会转换成 `false`。因为他们被称为 “falsy” 值。
 - 其他值变成 `true`，所以它们被称为 “truthy”。
+=======
+- 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".
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 所以，下面条件下的代码永远不会执行：
 
@@ -48,7 +77,11 @@ if (0) { // 0 是 falsy
 }
 ```
 
+<<<<<<< HEAD
 ……但下面的条件 — 始终有效：
+=======
+...and inside this condition -- it always will:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 if (1) { // 1 是 truthy
@@ -56,7 +89,11 @@ if (1) { // 1 是 truthy
 }
 ```
 
+<<<<<<< HEAD
 我们也可以将未计算的布尔值传入 `if` 语句，如下所示：
+=======
+We can also pass a pre-evaluated boolean value to `if`, like this:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 let cond = (year == 2015); // 相等运算符的结果是 true 或 false
@@ -68,11 +105,15 @@ if (cond) {
 
 ## "else" 语句
 
+<<<<<<< HEAD
 `if` 语句包含一个可选的 “else” 块。如果条件不成立，就会执行它内部的代码。
+=======
+The `if` statement may contain an optional "else" block. It executes when the condition is false.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如下所示：
 ```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) {
 
 ## 多个条件："else if"
 
+<<<<<<< HEAD
 有时我们需要测试一个条件的几个变体。使用 `else if` 子句可以实现。
+=======
+Sometimes, we'd like to test several variants of a condition. The `else if` clause lets us do that.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如下所示：
 
 ```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,6 +144,7 @@ if (year < 2015) {
 }
 ```
 
+<<<<<<< HEAD
 在上面的代码中，首先检查 `year < 2015`。如果它是假的，就会转到下一个条件 `year > 2015`，否则显示最后一个 `alert`。
 
 可以有更多的 `else if` 块。结尾的 `else` 是可选的。
@@ -106,6 +152,15 @@ if (year < 2015) {
 ## 三元运算符 '?'
 
 有时我们需要根据一个条件去声明变量。
+=======
+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.
+
+## Conditional operator '?'
+
+Sometimes, we need to assign a variable depending on a condition.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如下所示：
 
@@ -124,16 +179,26 @@ if (age > 18) {
 alert(accessAllowed);
 ```
 
+<<<<<<< HEAD
 所谓的“三元”或“问号”操作符让我们可以更简便地达到目的。
 
 它用问号 `?` 表示。“三元”意味着操作符有三个操作数。它实际上是JavaScript 中唯一一个有这么多操作数的操作符。
+=======
+The so-called "conditional" or "question mark" operator lets us do that in a shorter and simpler way.
+
+The operator is represented by a question mark `?`. Sometimes it's called "ternary", because the operator has three operands. It is actually the one and only operator in JavaScript which has that many.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 语法如下：
 ```js
-let result = condition ? value1 : value2
+let result = condition ? value1 : value2;
 ```
 
+<<<<<<< HEAD
 计算条件结果，如果结果为真，则返回 `value1`，否则返回 `value2`。
+=======
+The `condition` is evaluated: if it's truthy then `value1` is returned, otherwise -- `value2`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如下所示：
 
@@ -141,7 +206,13 @@ let result = condition ? value1 : value2
 let accessAllowed = (age > 18) ? true : false;
 ```
 
+<<<<<<< HEAD
 技术上，我们可以省略 `age > 18` 外面的括号。问号运算符的优先级较低。它在比较 `>` 后执行，所以也会执行相同的操作：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 // 比较运算符 “age > 18” 首先执行
@@ -149,10 +220,17 @@ let accessAllowed = (age > 18) ? true : false;
 let accessAllowed = age > 18 ? true : false;
 ```
 
+<<<<<<< HEAD
 但括号使代码更具可读性，所以建议使用它们。
 
 ````smart
 在上面的例子中，可以去掉问号运算符，因为比较本身就返回 `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`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 // 下面代码同样可以实现
@@ -162,7 +240,11 @@ let accessAllowed = age > 18;
 
 ## 多个 '?'
 
+<<<<<<< HEAD
 使用一系列问号 `?` 运算符可以返回一个取决于多个条件的值。
+=======
+A sequence of question mark operators `?` can return a value that depends on more than one condition.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如下所示：
 ```js run
@@ -176,6 +258,7 @@ let message = (age < 3) ? 'Hi, baby!' :
 alert( message );
 ```
 
+<<<<<<< HEAD
 很难一下子看出发生了什么。但经过仔细观察，我们可以看到它只是一个普通的检查序列。
 
 1. 第一个问号检查 `age < 3`。
@@ -184,6 +267,16 @@ alert( message );
 4. 如果为真 — 返回 `'Greetings!'`，否则 — 在最后一个冒号 `":"` 后面返回 `'What an unusual age!'`。
 
 使用 `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`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 if (age < 3) {
@@ -210,6 +303,7 @@ let company = prompt('Which company created JavaScript?', '');
 */!*
 ```
 
+<<<<<<< HEAD
 根据 `company =='Netscape'` 条件，要么执行 `?` 后面的第一部分方法并显示对应内容，要么执行第二部分的方法并显示对应内容。
 
 在这里我们不是把结果赋值给变量。而是根据条件执行不同的代码。
@@ -219,6 +313,17 @@ let company = prompt('Which company created JavaScript?', '');
 这种写法比 `if` 语句更短，对一些程序员很有吸引力。但它的可读性较差。
 
 下面是使用 `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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run no-beautify
 let company = prompt('Which company created JavaScript?', '');
@@ -232,6 +337,12 @@ if (company == 'Netscape') {
 */!*
 ```
 
+<<<<<<< HEAD
 因为我们的眼睛垂直扫描代码。跨越多行的结构比长的水平代码更容易理解。
 
 问号 `?` 的作用是根据条件返回一个或另一个值。请正确使用它。`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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
index 512fd6f33a..a2719ce0d9 100644
--- a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
+++ b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
@@ -4,7 +4,11 @@ importance: 5
 
 # 或运算的结果是什么？
 
+<<<<<<< HEAD
 如下代码将会输出什么？
+=======
+What is the code below going to output?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 alert( null || 2 || undefined );
diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
index fac364cc24..13a8df6b0f 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
@@ -4,7 +4,11 @@ importance: 3
 
 # 或运算和 alerts 的结果是什么？
 
+<<<<<<< HEAD
 下面的代码将会输出什么？
+=======
+What will the code below output?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 alert( alert(1) || 2 || alert(3) );
diff --git a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
index 2331e3e223..432bda60eb 100644
--- a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
+++ b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
@@ -4,7 +4,11 @@ importance: 5
 
 # 与操作的结果是什么？
 
+<<<<<<< HEAD
 下面这段代码将会显示什么？
+=======
+What is this code going to show?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 alert( 1 && null && 2 );
diff --git a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
index c98fae47c1..1fa3f30d73 100644
--- a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
@@ -12,5 +12,9 @@ alert( null || 2 && 3 || 4 );
 null || 3 || 4
 ```
 
+<<<<<<< HEAD
 现在的结果就是第一个真值：`3`。
+=======
+Now the result is the first truthy value: `3`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
diff --git a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
index 05b7f18aa7..226f7dd65e 100644
--- a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
+++ b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
@@ -4,7 +4,11 @@ importance: 5
 
 # 或运算、与运算、或运算串联的结果
 
+<<<<<<< HEAD
 结果将会是什么？
+=======
+What will the result be?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 alert( null || 2 && 3 || 4 );
diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
index 466673e2a9..aa1164a345 100644
--- a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
+++ b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
@@ -6,7 +6,11 @@ importance: 5
 
 下面哪一个 `alert` 将会被执行？
 
+<<<<<<< HEAD
 `if(...)` 语句内表达式的结果是什么？
+=======
+What will the results of the expressions be inside `if(...)`?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 if (-1 || 0) alert( 'first' );
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 0000000000..32f0d4b94c
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 0000000000..c3867e62c0
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 71%
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 9925377b9c..b3d0ab3de1 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 @@ importance: 3
 
 请使用嵌套的 `if` 块。注意代码整体的可读性。
 
+<<<<<<< HEAD:1-js/02-first-steps/10-ifelse/4-check-login/task.md
 提示：将空字符串输入，prompt 会获取到一个空字符串 `''`。Prompt 运行过程中，按下 `key:ESC` 键会得到 `null`。
+=======
+Hint:  passing an empty input to a prompt returns an empty string `''`. Pressing `key:ESC` during a prompt returns `null`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/02-first-steps/11-logical-operators/9-check-login/task.md
 
 [示例]
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 7a65d5bbbc..cc0feca378 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 @@
 
 JavaScript 里有三个逻辑运算符：`||` (或), `&&` (与), `!` (非)。
 
+<<<<<<< HEAD
 虽然被称为“逻辑”，这些运算符却可以被应用于任意类型的值，而不仅仅是布尔值。结果也同样可能是任意类型。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 让我们来详细看一下。
 
@@ -14,9 +18,15 @@ JavaScript 里有三个逻辑运算符：`||` (或), `&&` (与), `!` (非)。
 result = a || b;
 ```
 
+<<<<<<< HEAD
 在传统的编程中，逻辑或仅能够操作布尔值。如果参与运算的一个参数为 `true`，结果将返回 `true`，否则返回 `false`。
 
 在 JavaScript 中，逻辑运算符更加灵活强大。但是首先我们看一下操作数是布尔值的时候发生了什么。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 下面是四种可能的逻辑组合：
 
@@ -29,9 +39,15 @@ alert( false || false ); // false
 
 正如我们所见，除了两个操作数都是 `false` 的情况，结果总是 `true`。
 
+<<<<<<< HEAD
 如果操作数不是布尔值，那么它将会被转化为布尔值来参与运算。
 
 例如，数字 `1` 将会被作为 `true`，数字 `0` 则作为 `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`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 if (1 || 0) { // 工作原理相当于 if( true || false )
@@ -39,7 +55,11 @@ if (1 || 0) { // 工作原理相当于 if( true || false )
 }
 ```
 
+<<<<<<< HEAD
 大多数时间，或 `||` 会被用在 `if` 语句中，用来测试是否有**任何**给定的条件是正确的。
+=======
+Most of the time, OR `||` is used in an `if` statement to test if *any* of the given conditions is `true`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如：
 
@@ -64,9 +84,15 @@ if (hour < 10 || hour > 18 || isWeekend) {
 }
 ```
 
+<<<<<<< HEAD
 ## 或运算寻找第一个真值
 
 上文提到的逻辑处理多少有些传统了。下面让我们看看 JavaScript 的“附加”特性。
+=======
+## OR finds the first truthy value
+
+The logic described above is somewhat classical. Now, let's bring in the "extra" features of JavaScript.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 拓展的算法如下所示。
 
@@ -78,13 +104,23 @@ result = value1 || value2 || value3;
 
 或运算符 `||` 做了如下的事情：
 
+<<<<<<< HEAD
 - 从左到右依次计算操作数。
 - 将每一个操作数转化为布尔值。如果结果是 `true`，就停止计算，返回这个操作数的初始值。
 - 如果所有的操作数都被计算过（也就是，转换结果都是 `false`），返回最后一个操作数。
+=======
+- 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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 返回的值是操作数的初始形式，不会做布尔转换。
 
+<<<<<<< HEAD
 也就是，一个或 `"||"` 运算的链将返回第一个真值，如果这样的值不存在就返回该链的最后一个值。
+=======
+In other words, a chain of OR `"||"` returns the first truthy value or the last one if no truthy value is found.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如：
 
@@ -97,6 +133,7 @@ alert( null || 0 || 1 ); // 1（第一个真值）
 alert( undefined || null || 0 ); // 0（所有的转化结果都是 false，返回最后一个值）
 ```
 
+<<<<<<< HEAD
 对比与“纯粹的、传统的、仅仅处理布尔值的或运算”，这个就有很有趣的用法了。
 
 1. **获取变量列表或者表达式的第一个真值**
@@ -104,6 +141,15 @@ alert( undefined || null || 0 ); // 0（所有的转化结果都是 false，返
     假设我们有几个变量，它们可能包含某些数据或者是 `null/undefined`。我们需要选出第一个包含数据的变量。
 
     我们可以这样应用或运算 `||`：
+=======
+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 a list of variables which can either contain data or be `null/undefined`. How can we find the first one with data?
+
+    We can use OR `||`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js run
     let currentUser = null;
@@ -116,6 +162,7 @@ alert( undefined || null || 0 ); // 0（所有的转化结果都是 false，返
     alert( name ); // 选出了 “John” - 第一个真值
     ```
 
+<<<<<<< HEAD
     如果 `currentUser` 和 `defaultUser` 都是假值，那么结果就是 `"unnamed"`。
 2. **短路取值。**
 
@@ -124,6 +171,16 @@ alert( undefined || null || 0 ); // 0（所有的转化结果都是 false，返
     当表达式作为第二个参数并且有一定副作用，比如变量赋值的时候，这就清楚可见了。
 
     如果我们运行下面的例子，`x` 将不会被赋值：
+=======
+    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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js run no-beautify
     let x;
@@ -133,7 +190,11 @@ alert( undefined || null || 0 ); // 0（所有的转化结果都是 false，返
     alert(x); // undefined，因为 (x = 1) 没有被执行
     ```
 
+<<<<<<< HEAD
     ...如果第一个参数是 `false`，或运算将会继续并计算第二个参数，也就会运行赋值操作。
+=======
+    If, instead, the first argument is `false`, `||` evaluates the second one, thus running the assignment:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js run no-beautify
     let x;
@@ -143,11 +204,19 @@ alert( undefined || null || 0 ); // 0（所有的转化结果都是 false，返
     alert(x); // 1
     ```
 
+<<<<<<< HEAD
     赋值操作只是一个很简单的情况，其他副作用同样可以被包含进来。
 
     正如我们所见，这种用法是“`if` 语句的简便方式”。第一个操作数被转化为布尔值，如果是假，那么第二个参数就会被执行。
 
     大多数情况下，使用正常的 `if` 语句，这样代码可读性更高，但是有时候这种方式会很简洁。
+=======
+    An assignment is a simple case. There may be side effects, that won't show up if the evaluation doesn't reach them.
+
+    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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## &&（与）
 
@@ -157,7 +226,11 @@ alert( undefined || null || 0 ); // 0（所有的转化结果都是 false，返
 result = a && b;
 ```
 
+<<<<<<< HEAD
 传统的编程中，当两个操作数都是真值，与操作返回 `true`，否则返回 `false`：
+=======
+In classical programming, AND returns `true` if both operands are truthy and `false` otherwise:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 alert( true && true );   // true
@@ -173,11 +246,15 @@ let hour = 12;
 let minute = 30;
 
 if (hour == 12 && minute == 30) {
-  alert( 'Time is 12:30' );
+  alert( 'The time is 12:30' );
 }
 ```
 
+<<<<<<< HEAD
 就像或运算一样，与运算的操作数可以是任意类型的值：
+=======
+Just as with OR, any value is allowed as an operand of AND:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 if (1 && 0) { // 作为 true && false 来执行
@@ -186,7 +263,11 @@ if (1 && 0) { // 作为 true && false 来执行
 ```
 
 
+<<<<<<< HEAD
 ## 与操作寻找第一个假值
+=======
+## AND finds the first falsy value
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 给出多个参加与运算的值：
 
@@ -196,9 +277,15 @@ result = value1 && value2 && value3;
 
 与运算 `&&` 做了如下的事情：
 
+<<<<<<< HEAD
 - 从左到右依次计算操作数。
 - 将每一个操作数转化为布尔值。如果结果是 `false`，就停止计算，返回这个操作数的初始值。
 - 如果所有的操作数都被计算过（也就是，转换结果都是 `true`），返回最后一个操作数。
+=======
+- 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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 换句话说，与操作符返回第一个假值，如果没有假值就返回最后一个值。
 
@@ -230,6 +317,7 @@ alert( 1 && 2 && null && 3 ); // null
 alert( 1 && 2 && 3 ); // 3，最后一个值
 ```
 
+<<<<<<< HEAD
 ````smart header="与运算 `&&` 在或操作符 `||` 之前执行"
 与运算 `&&` 的优先级比或运算 `||` 要高，所以它将会比或运算先执行。
 
@@ -238,6 +326,12 @@ alert( 1 && 2 && 3 ); // 3，最后一个值
 ```js run
 alert( 5 || 1 && 0 ); // 5
 ```
+=======
+````smart header="Precedence of AND `&&` is higher than OR `||`"
+The precedence of AND `&&` operator is higher than OR `||`.
+
+So the code `a && b || c && d` is essentially the same as if the `&&` expressions were in parentheses: `(a && b) || (c && d)`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ````
 
 就像或运算一样，与运算 `&&` 有时候能够代替 `if`。
@@ -250,7 +344,11 @@ let x = 1;
 (x > 0) && alert( 'Greater than zero!' );
 ```
 
+<<<<<<< HEAD
 `&&` 右边的代码只有运算抵达到那里才能被执行。也就是，当且仅当 `(x > 0)` 返回了真值。
+=======
+The action in the right part of `&&` would execute only if the evaluation reaches it. That is, only if `(x > 0)` is true.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 所以我们基本可以类似的得到：
 
@@ -262,9 +360,15 @@ if (x > 0) {
 }
 ```
 
+<<<<<<< HEAD
 带 `&&` 的代码变体看上去更短。但是 `if` 的含义更明显，可读性也更高。
 
 所以建议是根据目的选择代码的结构。需要条件判断就用 `if`，需要与运算就用 `&&`。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## !（非）
 
@@ -278,8 +382,13 @@ result = !value;
 
 操作符接受一个参数，并按如下运作：
 
+<<<<<<< HEAD
 1. 将操作数转化为布尔类型：`true/false`。
 2. 返回相反的值。
+=======
+1. Converts the operand to boolean type: `true/false`.
+2. Returns the inverse value.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如：
 
@@ -295,7 +404,11 @@ alert( !!"non-empty string" ); // true
 alert( !!null ); // false
 ```
 
+<<<<<<< HEAD
 也就是，第一个非运算将该值转化为布尔类型并取反，第二个非运算再次取反。最后我们就得到了一个任意值到布尔值的转化。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这是一个更详细的方法，完成的同样的事情 -- 一个内置的 `Boolean` 函数：
 
@@ -303,3 +416,5 @@ alert( !!null ); // false
 alert( Boolean("non-empty string") ); // true
 alert( Boolean(null) ); // false
 ```
+
+The precedence of NOT `!` is the highest of all logical operators, so it always executes first, before `&&` or `||`.
diff --git a/1-js/02-first-steps/12-while-for/2-which-value-while/solution.md b/1-js/02-first-steps/12-while-for/2-which-value-while/solution.md
index abee806bb9..6f1d6f9836 100644
--- a/1-js/02-first-steps/12-while-for/2-which-value-while/solution.md
+++ b/1-js/02-first-steps/12-while-for/2-which-value-while/solution.md
@@ -7,18 +7,28 @@
     while (++i < 5) alert( i );
     ```
 
+<<<<<<< HEAD
     第一个值是 `i=1`，因为 `++i` 首先递增 `i` 然后返回新值。因此先比较 `1 < 5` 然后 `alert` 显示 `1`。
 
     然后按照 `2,3,4…` —— 数值一个接着一个出现。比较总是使用递增值，因为 `++` 在变量前。
 
     最终，`i=4` 递增到 `5`，当比较 `while(5 < 5)` 失败时，循环停止。所以没有显示 `5`。  
 2. **从 1 到 5**
+=======
+    The first value is `i = 1`, because `++i` first increments `i` and then returns the new value. So the first comparison is `1 < 5` and the `alert` shows `1`.
+
+    Then follow `2, 3, 4…` -- the values show up one after another. The comparison always uses the incremented value, because `++` is before the variable.
+
+    Finally, `i = 4` is incremented to `5`, the comparison `while(5 < 5)` fails, and the loop stops. So `5` is not shown.
+2. **From 1 to 5**
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js run
     let i = 0;
     while (i++ < 5) alert( i );
     ```
 
+<<<<<<< HEAD
     第一个值也是 `i=1`。后缀形式 `i++` 递增 `i` 然后返回**旧**值，因此比较 `i++ < 5` 将使用 `i=0` （与 `++i < 5` 相反）。
 
     但 `alert` 调用是独立的。这是在递增和比较之后执行的另一条语句。因此它得到了当前的 `i=1`。
@@ -28,3 +38,14 @@
     我们在 `i=4` 时暂停，前缀形式 `++i` 会递增并在比较中使用 `5`。但我们这里还有后缀形式 `i++`。因此，它将 `i` 递增到 `5`，但返回旧值。因此实际比较的是 `while(4 < 5)` —— true，控制继续执行 `alert`。
 
     `i=5` 是最后一个值，因为下一步 `while(5 < 5)` 为 false。
+=======
+    The first value is again `i = 1`. The postfix form of `i++` increments `i` and then returns the *old* value, so the comparison `i++ < 5` will use `i = 0` (contrary to `++i < 5`).
+
+    But the `alert` call is separate. It's another statement which executes after the increment and the comparison. So it gets the current `i = 1`.
+
+    Then follow `2, 3, 4…`
+
+    Let's stop on `i = 4`. The prefix form `++i` would increment it and use `5` in the comparison. But here we have the postfix form `i++`. So it increments `i` to `5`, but returns the old value. Hence the comparison is actually `while(4 < 5)` -- true, and the control goes on to `alert`.
+
+    The value `i = 5` is the last one, because on the next step `while(5 < 5)` is false.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/1-js/02-first-steps/12-while-for/2-which-value-while/task.md b/1-js/02-first-steps/12-while-for/2-which-value-while/task.md
index ce6ba71723..3fc3c878f2 100644
--- a/1-js/02-first-steps/12-while-for/2-which-value-while/task.md
+++ b/1-js/02-first-steps/12-while-for/2-which-value-while/task.md
@@ -2,11 +2,19 @@ importance: 4
 
 ---
 
+<<<<<<< HEAD
 # 哪个值才是 while？
 
 对于每次循环，写出你认为会显示的值，然后与答案进行比较。
 
 两次循环的 `alert` 值是否相同？
+=======
+# Which values does the while loop show?
+
+For every loop iteration, write down which value it outputs and then compare it with the solution.
+
+Both loops `alert` the same values, or not?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 1. 前缀形式 `++i`:
 
diff --git a/1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md b/1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md
index 43922b1fbd..8bdb3e8d3c 100644
--- a/1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md
+++ b/1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md
@@ -3,7 +3,11 @@ importance: 5
 
 # 重复输入，直到正确为止
 
+<<<<<<< HEAD
 编写一个提示输入大于 `100` 的循环。如果使用者输入其他数值 —— 请他重新输入。
+=======
+Write a loop which prompts for a number greater than `100`. If the visitor enters another number -- ask them to input again.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 循环必须请求一个数值，直到使用者输入一个大于 `100` 的数值或取消输入/输入空行为止。
 
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 741b287522..18a4b779c2 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
 这段代码有很大空间可以优化。例如，我们可以从 `2` 到 `i` 的平方根中寻找除数。但无论如何，如果我们想要在很大的时间间隔内实现高效率，我们需要改变方法，依赖高等数学和复杂算法，如[二次筛选] [Quadratic sieve](https://en.wikipedia.org/wiki/Quadratic_sieve), [General number field sieve](https://en.wikipedia.org/wiki/General_number_field_sieve) 等等。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 0a01a165a9..1f14606b66 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 @@
 # 循环：while 和 for
 
+<<<<<<< HEAD
 我们经常需要连续多次执行类似的操作。
 
 例如，我们需要从列表中逐个输出商品时，或者对从 1 到 10 的每个数字运行相同的代码时。
 
 **循环**是一种多次重复运行同一部分代码的方法。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## "while" 循环
 
@@ -31,11 +39,19 @@ while (i < 3) { // 结果分别是 0、1、2
 
 循环体的单次执行叫作**一次迭代**。上面示例中的循环进行三次迭代。
 
+<<<<<<< HEAD
 如果上述示例中没有 `i++`，那么循环（理论上）会永远重复。实际上，浏览器提供了阻止这种循环的方法，对于服务器端 JavaScript，我们可以终止该过程。
 
 任何表达式或变量都可以是循环条件，而不仅仅是比较。对它们进行计算，并通过 `while` 将其结果转化为布尔值。
 
 例如，`while (i != 0)` 可简写为 `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)`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let i = 3;
@@ -47,8 +63,13 @@ while (i) { // 当 i 变成 0 时，条件为 false，循环终止
 }
 ```
 
+<<<<<<< HEAD
 ````smart header="Brackets are not required for a single-line body"
 如果循环体只有一条语句，则可以省略括号 `{…}`：
+=======
+````smart header="Curly braces are not required for a single-line body"
+If the loop body has a single statement, we can omit the curly braces `{…}`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let i = 3;
@@ -68,7 +89,11 @@ do {
 } while (condition);
 ```
 
+<<<<<<< HEAD
 循环首先执行循环体，然后检查条件，当条件为真时，重复执行循环体。
+=======
+The loop will first execute the body, then check the condition, and, while it's truthy, execute it again and again.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如：
 
@@ -80,11 +105,19 @@ do {
 } while (i < 3);
 ```
 
+<<<<<<< HEAD
 这种形式的语法很少使用，除非您希望不管条件是否为真，循环体**至少执行一次**。通常其他形式是首选：`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(…) {…}`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## "for" 循环
 
+<<<<<<< HEAD
 `for` 循环是最常使用的。
+=======
+The `for` loop is the most commonly used loop.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 看起来就像这样：
 
@@ -102,6 +135,7 @@ for (let i = 0; i < 3; i++) { // 结果为 0、1、2
 }
 ```
 
+<<<<<<< HEAD
 我们逐部分地检查 `for` 语句：
 
 | 部分 |          |                                                                            |
@@ -110,6 +144,16 @@ for (let i = 0; i < 3; i++) { // 结果为 0、1、2
 | 条件 | `i < 3`| 在每次循环迭代之前检查，如果失败，循环停止。          |
 | 步骤 | `i++`      | 在每次迭代后执行主体，但在条件检查之前执行。 |
 | 主体 | `alert(i)`| 条件为真时，重复运行。                        |
+=======
+Let's examine the `for` statement part-by-part:
+
+| part  |          |                                                                            |
+|-------|----------|----------------------------------------------------------------------------|
+| 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.                         |
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 
 一般循环算法的工作原理如下：
@@ -121,9 +165,15 @@ Run begin
 → ...
 ```
 
+<<<<<<< HEAD
 如果您是循环方面的小白，那么回到这个例子，在一张纸上重现它逐步运行的过程，可能会对你有所帮助。
 
 以下是我们示例中发生的情况：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 // for (let i = 0; i < 3; i++) alert(i)
@@ -140,7 +190,11 @@ if (i < 3) { alert(i); i++ }
 ```
 
 ````smart header="Inline variable declaration"
+<<<<<<< HEAD
 这里“计数”变量 `i` 在循环中声明。这叫做“内联”变量声明。这样的变量只在循环中可见。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 for (*!*let*/!* i = 0; i < 3; i++) {
@@ -149,7 +203,11 @@ for (*!*let*/!* i = 0; i < 3; i++) {
 alert(i); // 错误，没有这个变量。
 ```
 
+<<<<<<< HEAD
 我们可以使用现有的变量而不是定义变量：
+=======
+Instead of defining a variable, we could use an existing one:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let i = 0;
@@ -190,9 +248,15 @@ for (; i < 3;) {
 }
 ```
 
+<<<<<<< HEAD
 该循环与 `while (i < 3)` 等价。
 
 实际上我们可以删除所有内容，从而创建一个无限循环：
+=======
+This makes the loop identical to `while (i < 3)`.
+
+We can actually remove everything, creating an infinite loop:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 for (;;) {
@@ -200,15 +264,27 @@ for (;;) {
 }
 ```
 
+<<<<<<< HEAD
 请注意 `for` 的两个 `;` 必须存在，否则会出现语法错误。
+=======
+Please note that the two `for` semicolons `;` must be present. Otherwise, there would be a syntax error.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 跳出循环
 
+<<<<<<< HEAD
 通常条件为假时，循环会终止。
 
 但我们随时都可以强制退出，因为有一个特殊的 `break` 指令可以做到这一点。
 
 例如，下述循环要求用户输入一系列数字，但会在没有数字输入时候“终止”。
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 let sum = 0;
@@ -227,15 +303,27 @@ while (true) {
 alert( 'Sum: ' + sum );
 ```
 
+<<<<<<< HEAD
 如果用户输入空行或取消输入，在 `(*)` 行 `break` 指令会被激活。它立刻终止循环，将控制权传递给循环后的第一行，即，`alert`。
 
 根据需要，"无限循环 + `break`" 的组合非常适用于不必在循环开始/结束时检查条件，但在中间甚至是主体的多个位置进行检查的情况。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 继续下一次迭代 [#continue]
 
+<<<<<<< HEAD
 `continue` 指令是 `break` 的“轻量版”。这并不能阻止整个循环。相反，它将停止当前的迭代，并强制启动新一轮循环（如果条件允许的话）。
 
 如果我们完成了当前的迭代，并且希望继续执行下一次迭代，我们就可以使用它。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 下述循环使用 `continue` 只输出奇数：
 
@@ -249,10 +337,17 @@ for (let i = 0; i < 10; i++) {
 }
 ```
 
+<<<<<<< HEAD
 对于偶数的 `i`，`continue` 指令停止执行，将控制权传递给下一次 `for`（使用下一个数字）的迭代。因此 `alert` 仅被奇数值调用。
 
 ````smart header="The directive `continue` helps to decrease nesting level"
 显示奇数的循环如下所示：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 for (let i = 0; i < 10; i++) {
@@ -264,6 +359,7 @@ for (let i = 0; i < 10; i++) {
 }
 ```
 
+<<<<<<< HEAD
 从技术角度看，它与上述示例完全相同。当然，我们可以将代码包装在 `if` 块而不是 `continue` 块。
 
 但作为副作用，我们还有一个嵌套级别（花括号内的 `alert` 调用）。如果 `if` 中代码超过几行，则可能会降低总体可读性。
@@ -271,6 +367,15 @@ for (let i = 0; i < 10; i++) {
 
 ````warn header="No `break/continue` to the right side of '?'"
 请注意非表达式的语法结构不能与三元运算符 `?` 一起使用。特别是 `break/continue` 这样的指令是不被允许使用的。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如，我们使用如下代码：
 
@@ -282,24 +387,39 @@ if (i > 5) {
 }
 ```
 
+<<<<<<< HEAD
 ...然后用问号重写：
+=======
+...and rewrite it using a question mark:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 
 ```js no-beautify
-(i > 5) ? alert(i) : *!*continue*/!*; // continue not allowed here
+(i > 5) ? alert(i) : *!*continue*/!*; // continue isn't allowed here
 ```
 
+<<<<<<< HEAD
 ...然后会停止运行。这样的代码将给出语法错误：
 
 
 这只是不适用 `?` 而不是 `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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ````
 
 ## break/continue 标签
 
 有时候我们需要从多个嵌套循环中跳出来。
 
+<<<<<<< HEAD
 例如，下述代码中我们的循环使用 `i` 和 `j`，提示坐标 `(i, j)` 从 `(0,0)` 到 `(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)`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run no-beautify
 for (let i = 0; i < 3; i++) {
@@ -318,7 +438,11 @@ alert('Done!');
 
 如果用户取消输入，我们需要另一种方法来停止这个过程。
 
+<<<<<<< HEAD
 在 `input` 之后的普通 `break` 只会打破内部循环。这还不够。标签可以拯救。
+=======
+The ordinary `break` after `input` would only break the inner loop. That's not sufficient--labels, come to the rescue!
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 **标签**是在循环之前带有冒号的标识符：
 ```js
@@ -327,9 +451,13 @@ labelName: for (...) {
 }
 ```
 
+<<<<<<< HEAD
 `break <labelName>` 语句跳出循环至标签处。
 
 就像这样：
+=======
+The `break <labelName>` statement in the loop below breaks out to the label:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run no-beautify
 *!*outer:*/!* for (let i = 0; i < 3; i++) {
@@ -347,7 +475,11 @@ labelName: for (...) {
 alert('Done!');
 ```
 
+<<<<<<< HEAD
 上述代码中，`break outer` 向上寻找名为 `outer` 的标签并跳出当前循环。
+=======
+In the code above, `break outer` looks upwards for the label named `outer` and breaks out of that loop.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 因此，控制权直接从 `(*)` 转至 `alert('Done!')`。
 
@@ -358,10 +490,17 @@ outer:
 for (let i = 0; i < 3; i++) { ... }
 ```
 
+<<<<<<< HEAD
 `continue` 指令也可以与标签一起使用。在这种情况下，执行跳转到标记循环的下一次迭代。
 
 ````warn header="Labels are not a \"goto\""
 标签不允许我们跳到任意代码位置。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如，这样做是不可能的：
 ```js
@@ -370,7 +509,11 @@ break label;  // 跳转到标签？不。
 label: for (...)
 ```
 
+<<<<<<< HEAD
 只有在循环内部才能调用 `break/continue`，并且标签必须位于指令上方的某个位置。 
+=======
+A call to `break/continue` is only possible from inside a loop and the label must be somewhere above the directive.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ````
 
 ## 总结
@@ -383,6 +526,12 @@ label: for (...)
 
 通常使用 `while(true)` 来构造“无限”循环。这样的循环就像任何其他循环一样，可以通过 `break` 指令来终止。
 
+<<<<<<< HEAD
 如果我们不想在当前迭代中做任何事，并且想要转移至下一次迭代，那么 `continue` 指令就会执行它。
 
 `break/continue` 支持循环前的标签。标签是 `break/continue` 避免嵌套并转到外部循环的唯一方法。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/1-js/02-first-steps/13-switch/article.md b/1-js/02-first-steps/13-switch/article.md
index 0f53e310f2..5a546344ad 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 @@ switch (a) {
 比如，我们来看下面的代码：
 
 ```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/4-pow/task.md b/1-js/02-first-steps/14-function-basics/4-pow/task.md
index 7acf9d7102..e66ddbd966 100644
--- a/1-js/02-first-steps/14-function-basics/4-pow/task.md
+++ b/1-js/02-first-steps/14-function-basics/4-pow/task.md
@@ -9,7 +9,7 @@ importance: 4
 ```js
 pow(3, 2) = 3 * 3 = 9
 pow(3, 3) = 3 * 3 * 3 = 27
-pow(1, 100) = 1 * 1 * ...*1 = 1
+pow(1, 100) = 1 * 1 * ...* 1 = 1
 ```
 
 创建一个 web  页面，提示输入 `x` 和 `n` 然后返回 `pow(x,n)` 的函数值。
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 47f42f324b..4ed37cb742 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -101,7 +101,11 @@ showMessage();
 alert( userName ); // *!*Bob*/!*, 值被函数修改
 ```
 
+<<<<<<< HEAD
 只有在没有本地变量的情况下才会使用外部变量。因此如果我们忘记了 `let`，可能会发生意外修改的情况。
+=======
+The outer variable is only used if there's no local one.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如果在函数中声明了同名变量，那么它**遮蔽**外部变量。例如，在如下代码中，函数使用本地的 `userName`，外部部分被忽略：
 
@@ -128,7 +132,11 @@ alert( userName ); // *!*John*/!*，未更改，函数没有访问外部变量
 
 全局变量在任意函数中都是可见的(除非被局部变量遮蔽)。
 
+<<<<<<< HEAD
 通常，函数声明与任务相关的所有变量。全局变量只存储项目级的数据，所以这些变量从任何地方都可以访问是很重要的事情。现代的代码有很少或没有全局变量。大多数变量存在于它们的函数中。
+=======
+It's a good practice to minimize the use of global variables. Modern code has few or no globals. Most variables reside in their functions. Sometimes though, they can be useful to store project-level data.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ## 参数
@@ -204,6 +212,12 @@ function showMessage(from, text = anotherFunction()) {
 }
 ```
 
+```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.
+
+```
+
 
 ````smart header="Default parameters old-style"
 旧版本的 JavaScript 不支持默认参数。所以有其他的方法来支持它们，您可以在旧的脚本中找到。
@@ -263,7 +277,7 @@ function checkAge(age) {
 */!*
   } else {
 *!*
-    return confirm('Got a permission from the parents?');
+    return confirm('Do you have permission from your parents?');
 */!*
   }
 }
@@ -334,7 +348,11 @@ return*!*;*/!*
 
 ## 函数命名 [#function-naming]
 
+<<<<<<< HEAD
 函数是行为。所以它们的名字通常是动词。它应该简短且尽可能准确地描述函数的作用。这样读代码的人就能得到正确的线索。
+=======
+Functions are actions. So their name is usually a verb. It should be brief, as accurate as possible and describe what the function does, so that someone reading the code gets an indication of what the function does.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 一种普遍的做法是用动词前缀来开始一个函数，这个前缀模糊地描述了这个动作。团队内部必须就前缀的含义达成一致。
 
@@ -366,19 +384,33 @@ checkPermission(..) // 检查权限并返回 true/false
 
 有几个违反这一规则的例子：
 
+<<<<<<< HEAD
 - `getAge` —— 如果它显示一个 `alert` 和这个 age（只应该得到），那就是有问题的。
 - `createForm` —— 如果它修改文档，向它添加一个表单(只应该创建它并返回)，那就是有问题的。
 - `checkPermission` —— 如果显示 `access granted/denied` 消息(只应执行检查并返回结果)，那就是错误的。
 
 这些例子具有前缀的共同含义。它们对您的意义取决于您和您的团队。也许您的代码行为不同是很正常的。但是您应该对前缀意味着什么，前缀函数能做什么和不能做什么有一个明确的理解。所有相同的前缀函数都应遵守规则。团队应该分享知识。
+=======
+- `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).
+
+These examples assume common meanings of prefixes. You and your team are free to agree on other meanings, but usually they're not much different. In any case, you should have a firm understanding of what a prefix means, what a prefixed function can and cannot do. All same-prefixed functions should obey the rules. And the team should share the knowledge.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ```smart header="Ultrashort function names"
 常用的函数有时会有**非常短**的名字。
 
+<<<<<<< HEAD
 例如，[jQuery](http://jquery.com) 框架定义函数用 `$`。[LoDash](http://lodash.com/) 库的核心函数命名用 `_`。
 
 这些都是例外，一般而言，函数名应简明扼要且具有描述性。
+=======
+For example, the [jQuery](http://jquery.com) framework defines a function with `$`. The [Lodash](http://lodash.com/) library has its core function named `_`.
+
+These are exceptions. Generally functions names should be concise and descriptive.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ## 函数 == 注释
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 7eb6e11e54..f5e6f94183 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 e629bd712c..c31b2636a6 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/15-function-expressions-arrows/article.md b/1-js/02-first-steps/15-function-expressions-arrows/article.md
index e4f5da2a18..90991c6ba8 100644
--- a/1-js/02-first-steps/15-function-expressions-arrows/article.md
+++ b/1-js/02-first-steps/15-function-expressions-arrows/article.md
@@ -78,8 +78,13 @@ let func = sayHi;
 这两种声明的函数是一样的，那么他们有什么不同的地方呢？
 
 
+<<<<<<< HEAD
 ````smart header="Why there's a semicolon at the end?"
  这里可能有个疑问，为什么函数表达式结尾有一个 `;`，而函数声明没有：
+=======
+````smart header="Why is there a semicolon at the end?"
+You might wonder, why does Function Expression have a semicolon `;` at the end, but Function Declaration does not:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 function sayHi() {
@@ -175,7 +180,11 @@ ask(
 
 让我们来阐述函数声明和表达式之间的关键区别。
 
+<<<<<<< HEAD
 首先是语法：看下面代码
+=======
+First, the syntax: how to differentiate between them in the code.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - **函数声明：** 函数在主代码流中单独声明。
 
@@ -185,8 +194,13 @@ ask(
       return a + b;
     }
     ```
+<<<<<<< HEAD
 - **函数表达式：** 一个函数，在一个表达式中或另一个语法结构中创建。这里，该函数由赋值表达式 `=` 右侧创建：
     
+=======
+- *Function Expression:* a function, created inside an expression or inside another syntax construct. Here, the function is created at the right side of the "assignment expression" `=`:
+
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
     ```js
     // Function Expression
     let sum = function(a, b) {
@@ -198,11 +212,19 @@ ask(
 
 **函数表达式在执行到达时创建并可用。**
 
+<<<<<<< HEAD
 一旦执行到右侧分配 `let sum = function…`，就会创建并可以使用(复制，调用等)。
+=======
+Once the execution flow passes to the right side of the assignment `let sum = function…` -- here we go, the function is created and can be used (assigned, called, etc. ) from now on.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 函数声明则不同。
 
+<<<<<<< HEAD
 **函数声明可用于整个脚本/代码块。**
+=======
+**A Function Declaration is usable in the whole script (or a code block, if it's inside a block).**
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 换句话说，当 JavaScript **准备**运行脚本或代码块时，它首先在其中查找函数声明并创建函数。我们可以将其视为“初始化阶段”。
 
@@ -350,8 +372,13 @@ welcome(); // ok now
 ```
 
 
+<<<<<<< HEAD
 ```smart header="When to choose Function Declaration versus Function Expression?"
 作为一个经验，当我们需要声明一个函数时，首先要考虑的是函数声明语法，这是我们之前使用的语法。它给如何组织我们的代码提供了更多的自由，因为我们可以在声明它们之前调用这些函数。
+=======
+```smart header="When should you choose Function Declaration versus Function Expression?"
+As a rule of thumb, when we need to declare a function, the first to consider is Function Declaration syntax, the one we used before. It gives more freedom in how to organize our code, because we can call such functions before they are declared.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在代码中查找 `function f(…) {…}` 比 `let f = function(…) {…}` 更容易。
 
@@ -375,7 +402,7 @@ let func = (arg1, arg2, ...argN) => expression
 ```js
 let func = function(arg1, arg2, ...argN) {
   return expression;
-}
+};
 ```
 
 ...精简下。
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 f8c6018e85..efd848be1d 100644
--- a/1-js/02-first-steps/16-javascript-specials/article.md
+++ b/1-js/02-first-steps/16-javascript-specials/article.md
@@ -102,9 +102,14 @@ typeof function(){} == "function" // 函数特殊
 
 ## 交互
 
+<<<<<<< HEAD
 我们使用浏览器作为工作环境，所以基本的 UI 功能将是：
 [`prompt(question[, default])`](mdn:api/Window/prompt)
 : 询问一个问题，并返回访问者输入的内容，如果他按下「取消」则返回 `null`。
+=======
+[`prompt(question, [default])`](mdn:api/Window/prompt)
+: Ask a `question`, and return either what the visitor entered or `null` if they clicked "cancel".
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 [`confirm(question)`](mdn:api/Window/confirm)
 : 提出一个问题，并建议在确定和取消之间进行选择。该选项以 `true/false` 形式返回。
@@ -112,7 +117,11 @@ typeof function(){} == "function" // 函数特殊
 [`alert(message)`](mdn:api/Window/alert)
 : 输出一个 `消息`。
 
+<<<<<<< HEAD
 所有这些函数都会产生**模态框**，它们会暂停代码执行并阻止访问者与页面交互，直到用户输入内容。
+=======
+All these functions are *modal*, they pause the code execution and prevent the visitor from interacting with the page until they answer.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 举个例子：
 
@@ -148,8 +157,13 @@ JavaScript 支持以下运算符：
 三元运算
 : 唯一具有三个参数的操作：`cond？ resultA: resultB`。如果 `cond` 是真的，则返回 `resultA`，否则返回 `resultB`。
 
+<<<<<<< HEAD
 逻辑运算符
 : 逻辑与 `&&` 和或 `||` 执行短路评估，然后返回停止时的值。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 比较运算符
 : 运算符 `==` 将不同类型的值转换为一个数字（除了 `null` 和 `undefined`，它们彼此相等而没有别的情况），所以下面的例子是相等的：
@@ -160,12 +174,25 @@ JavaScript 支持以下运算符：
     ```
     其他比较也转换为数字。
 
+<<<<<<< HEAD
     严格相等运算符 `===` 不会进行转换：不同的类型总是为其指定不同的值，因此：
     值 `null` 和 `undefined` 是特殊的：它们只在 `==` 下相等。
     字符串按照字符顺序逐一比较，其他类型转换为数字。
 
 逻辑运算符
 : 其他合规的运算符比较少，其中有逗号运算符。
+=======
+    Other comparisons convert to a number as well.
+
+    The strict equality operator `===` doesn't do the conversion: different types always mean different values for it.
+
+    Values `null` and `undefined` are special: they equal `==` each other and don't equal anything else.
+
+    Greater/less comparisons compare strings character-by-character, other types are converted to a number.
+
+Other operators
+: There are few others, like a comma operator.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 More in: <info:operators>, <info:comparison>, <info:logical-operators>.
 更多信息：<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 2b69951f14..26aa6d3c39 100644
--- a/1-js/03-code-quality/01-debugging-chrome/article.md
+++ b/1-js/03-code-quality/01-debugging-chrome/article.md
@@ -20,7 +20,11 @@
 
 切换按钮 <span class="devtools" style="background-position:-168px -76px"></span> 会打开文件列表的选项卡。
 
+<<<<<<< HEAD
 让我们在预览树中点击和选择 `index.html` 和 `hello.js`。应该会出现这个视图：
+=======
+Let's click it and select `hello.js` in the tree view. Here's what should show up:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ![](chrome-tabs.png)
 
@@ -34,7 +38,11 @@
 
 ## Console（控制台）
 
+<<<<<<< HEAD
 如果我们按下 `Esc`，下面会出现一个控制台，我们可以输入一些命令然后按下 `key:Enter` 来执行。
+=======
+If we press `key:Esc`, then a console opens below. We can type commands there and press `key:Enter` to execute.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 语句执行之后，会将其结果显示在下面。
 
@@ -56,11 +64,19 @@
 
 当代码被暂停时，我们可以检查当前的变量、在控制台执行命令等等。换句话说，我们可以调试它。
 
+<<<<<<< HEAD
 我们总是可以在右侧的面板中找到断点的列表。当我们在数个文件中有许多断点时，这是非常有用的。
 - 快速跳转至代码中的断点（通过点击右侧面板中的对应的断点）。
 - 通过取消选中来临时禁用。
 - 通过右键单击和选择移除来删除一个断点。
 - 等等。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```smart header="条件断点"
 在行号上**右键单击**允许你创建一个**条件**断点。只有当给定的条件为真（即满足条件）时才会被触发。
@@ -169,10 +185,17 @@ for (let i = 0; i < 5; i++) {
 
 ## 总结
 
+<<<<<<< HEAD
 我们可以看到，有 3 种方式来暂停一个脚本：
 1. 一个断点。
 2. `debugger` 声明。
 3. 一个错误（如果开发者工具是打开状态并且按钮 <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").
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 然后我们就能检查变量，并逐步查看执行器在哪里走错路了。
 
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 efa3c19df1..abc59905a2 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 e184bdd01f..546615e30e 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 2fe449c9b6..caf60ebb61 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 e4abc89d1f..3f628b6ffc 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 98b22e777c..0fc22b2ea6 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 3269a80f06..f01a7d1017 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 719293d2e5..424ca26b0a 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 5c22ab361b..04cc849d10 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 1848ccfacf..00507833a3 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 fcabf722eb..d2a38bf0c9 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 ff91c531f8..df9e13f3fb 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 09b10bf48d..5793bd0596 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 3ce1ed0d20..8aa0800943 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
@@ -2,6 +2,7 @@
 你可以注意到以下几点：
 
 ```js no-beautify
+<<<<<<< HEAD
 function pow(x,n)  // <- 参数之间没有空格
 {  // <- 大括号单独一行
   let result=1;   // <- = 号两边没有空格
@@ -15,11 +16,30 @@ let x=prompt("x?",''), n=prompt("n?",'') // <-- 从技术角度来看是可以
 if (n<0)  // <- (n < 0) 里面没有空格，并且应该在前面加一个空行
 {   // <- 大括号单独一行
   // 下面的一行太长了，或许拆分成 2 行更好
+=======
+function pow(x,n)  // <- no space between arguments
+{  // <- figure bracket on a separate line
+  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 missing ;
+if (n<0)  // <- no spaces inside (n < 0), and should be extra line above it
+{   // <- figure bracket on a separate line
+  // below - long lines can be split into multiple lines for improved readability
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
   alert(`Power ${n} is not supported, please enter an integer number greater than zero`);
 }
 else // <- 可以像 "} else {" 这样写在一行上
 {
+<<<<<<< HEAD
   alert(pow(x,n))  // 没有空格和 ;
+=======
+  alert(pow(x,n))  // no spaces and missing ;
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 }
 ```
 
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 47cd5b680b..ec8553087b 100644
--- a/1-js/03-code-quality/02-coding-style/article.md
+++ b/1-js/03-code-quality/02-coding-style/article.md
@@ -1,14 +1,26 @@
+<<<<<<< HEAD
 # 代码风格
+=======
+# Coding Style
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 我们的代码必须尽可能的清晰和易读。
 
+<<<<<<< HEAD
 这实际是一种编程艺术 —— 以一种正确并且人类易读的方式编码来完成一个复杂的任务。
 
 有一个帮助你（实现上面的目标）的事情就是良好的代码风格。
+=======
+That is actually the art of programming -- to take a complex task and code it in a way that is both correct and human-readable.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 语法
 
+<<<<<<< HEAD
 一个含有规则的备忘录（更多细节如下）：
+=======
+Here is a cheatsheet with some suggested rules (see below for more details):
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ![](code-style.png)
 <!--
@@ -38,6 +50,7 @@ if (n < 0) {
 
 现在我们来讨论一下图中的规则和它们的原因吧。
 
+<<<<<<< HEAD
 没有什么规则是“刻在石头上”的，每一条都是可选的而且可修改的：这些是编码规则，而不是宗教教条。
 
 ### Figure brackets（大括号）
@@ -45,6 +58,15 @@ if (n < 0) {
 在大多数的 JavaScript 中，大括号（的开始部分）都是写在同一行而不是新换一行。这就是所谓的 "egyptian" 风格。（译者注： "egyptian" 风格又称 K&R 风格 —— 代码段括号的开始位于一行的末尾，而不是另外起一行的风格。）对了，在括号的开始部分前面还有一个空格。
 
 例如：
+=======
+```warn header="Irony Detected"
+Nothing is set in stone here. These are style preferences, not religious dogmas.
+```
+
+### Curly Braces
+
+In most JavaScript projects curly braces are written in "Egyptian" style with the opening brace on the same line as the corresponding keyword -- not on a new line. There should also be a space before the opening bracket, like this:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 if (condition) {
@@ -56,7 +78,11 @@ if (condition) {
 
 单行结构也是一个重要的用例。我们是否应该使用括号？如果是，那么在哪里？
 
+<<<<<<< HEAD
 下面是这几种情况的注释，你可以自己判断一下它们的可读性：
+=======
+Here are the annotated variants so you can judge their readability for yourself:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 <!--
 ```js no-beautify
@@ -74,6 +100,7 @@ if (n < 0) {
 -->
 ![](figure-bracket-style.png)
 
+<<<<<<< HEAD
 总结：
 - 对于很短的代码，一行是可以接受的：例如 `if (cond) return null`.
 - 但是括号中的每个语句单独一行通常更好些。
@@ -83,12 +110,27 @@ if (n < 0) {
 一行的最大长度应该有所限制。没有人喜欢盯着一条长长的水平线。最好把它分割一下。
 
 一行的最大长度在团队层面上达成一致即可。通常是 80 或 120 个字符。
+=======
+In summary:
+- For very short code, one line is acceptable. For example: `if (cond) return null`.
+- But a separate line for each statement in brackets is usually easier to read.
+
+### Line Length
+
+No one likes to read a long horizontal line of code. It's best practice to split them up and limit the length of your lines.
+
+The maximum line length should be agreed upon at the team-level. It's usually 80 or 120 characters.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ### 缩进
 
 有两种类型的缩进：
 
+<<<<<<< HEAD
 - **水平方向上的缩进: 2(4) 个空格。**
+=======
+- **Horizontal indents: 2 or 4 spaces.**
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     一个水平缩进通常由 2 或 4 个空格或者 "Tab" 制表符构成。选择哪一个方式是一场古老的圣战。如今空格更普遍一点。
 
@@ -107,9 +149,15 @@ if (n < 0) {
     }
     ```
 
+<<<<<<< HEAD
 - **垂直方向上的缩进：用于将逻辑块中的代码进行分割的空行。**
 
     即使是单个函数通常也被分割为数个逻辑块。在下面的例子中，初始化的变量、主要的循环结构和返回值都被垂直分割了。
+=======
+- **Vertical indents: empty lines for splitting code into logical blocks.**
+
+    Even a single function can often be divided into logical blocks. In the example below, the initialization of variables, the main loop and returning the result are split vertically:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js
     function pow(x, n) {
@@ -125,6 +173,7 @@ if (n < 0) {
 
     插入一个额外的空行有助于让代码更加地易读。连续超过 9 行都没有被垂直分割的代码是不应该出现的。
 
+<<<<<<< HEAD
 ### 分号
 
 每一个语句后面都应该有一个分号。即使它可能会被跳过。
@@ -140,6 +189,23 @@ if (n < 0) {
 有时候在循环中使用 ["continue"](info:while-for#continue) 指令避免额外的 `if(..) { ... }` 嵌套是一个好主意：
 
 例如：
+=======
+### Semicolons
+
+A semicolon should be present after each statement, even if it could possibly be skipped.
+
+There are languages where a semicolon is truly optional and it is rarely used. In JavaScript, though, there are cases where a line break is not interpreted as a semicolon, leaving the code vulnerable to errors.
+
+As you become more mature as a programmer, you may choose a no-semicolon style like [StandardJS](https://standardjs.com/). Until then, it's best to use semicolons to avoid possible pitfalls.
+
+### Nesting Levels
+
+Try to avoid nesting code too many levels deep.
+
+Sometimes it's a good idea to use the ["continue"](info:while-for#continue) directive in a loop to avoid extra nesting.
+
+For example, instead of adding a nested `if` conditional like this:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 for (let i = 0; i < 10; i++) {
@@ -162,7 +228,11 @@ for (let i = 0; i < 10; i++) {
 
 例如，下面的两个结构是相同的。
 
+<<<<<<< HEAD
 第一个：
+=======
+Option 1:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 function pow(x, n) {
@@ -180,7 +250,11 @@ function pow(x, n) {
 }
 ```
 
+<<<<<<< HEAD
 还有这个：
+=======
+Option 2:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 function pow(x, n) {
@@ -199,6 +273,7 @@ function pow(x, n) {
 }
 ```
 
+<<<<<<< HEAD
 但是第二个更加的可读，因为 `n < 0` 这个”边缘情况“已经提前被处理过，并且我们有一个 ”主“ 代码流，而不需要额外的嵌套。
 
 ## 函数在代码下面
@@ -206,6 +281,15 @@ function pow(x, n) {
 如果你正在写几个”辅助类“的函数和一些使用它们的代码，有三种方式来放置它们。
 
 1. 函数在调用它们的那些代码之上：
+=======
+The second one is more readable because the "edge case" of `n < 0` is handled early on. Once the check is done we can move on to the "main" code flow without the need for additional nesting.
+
+## Function Placement
+
+If you are writing several "helper" functions and the code that uses them, there are three ways to organize the functions.
+
+1. Functions declared above the code that uses them:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js
     // *!*函数声明*/!*
@@ -235,7 +319,6 @@ function pow(x, n) {
     walkAround();
 
     // --- *!*helper functions*/!* ---
-
     function createElement() {
       ...
     }
@@ -248,10 +331,15 @@ function pow(x, n) {
       ...
     }
     ```
+<<<<<<< HEAD
 3. 混合，函数定义在它第一次被使用的地方。
+=======
+3. Mixed: a function is declared where it's first used.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 大多数时候，第二种方式更好。
 
+<<<<<<< HEAD
 这是因为当在阅读代码时，我们首先想要知道的是“它做了什么”。如果代码先行，它就会提供这些信息。或许我们一点也不需要阅读这些函数，尤其是他们的名字足够表示出他们做了什么的时候。
 
 ## 风格指南
@@ -263,11 +351,25 @@ function pow(x, n) {
 当然，一个团队可能会考虑一个他们自己的风格指南。但是现在，他们没必要这样做。现在有很多已经尝试过并制作好的风格指南，可以很容易采用。
 
 例如：
+=======
+That's because when reading code, we first want to know *what it does*. If the code goes first, then it provides that information. Then, maybe we won't need to read the functions at all, especially if their names are descriptive of what they actually do.
+
+## Style Guides
+
+A style guide contains general rules about "how to write" code, e.g. which quotes to use, how many spaces to indent, where to put line breaks, etc. A lot of minor things.
+
+When all members of a team use the same style guide, the code looks uniform, regardless of which team member wrote it.
+
+Of course, a team can always write their own style guide. Most of the time though, there's no need to. There are many existing tried and true options to choose from, so adopting one of these is usually your best bet.
+
+Some popular choices:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - [Google JavaScript 风格指南](https://google.github.io/styleguide/javascriptguide.xml)
 - [Airbnb JavaScript 风格指南](https://github.com/airbnb/javascript)
 - [Idiomatic.JS](https://github.com/rwaldron/idiomatic.js)
 - [StandardJS](https://standardjs.com/)
+<<<<<<< HEAD
 - (还有很多)
 
 如果你是一个初学者，你可以从本章中上面的内容开始，然后浏览风格指南并提取出常见规则或者选择一个。
@@ -281,6 +383,19 @@ function pow(x, n) {
 因此推荐你安装一个，即使你不想坚持某个 "code style"。它们会帮你找出书写错误 —— 这就已经足够好了。
 
 最出名的工具有：
+=======
+- (plus many more)
+
+If you're a novice developer, start with the cheatsheet at the beginning of this chapter. Once you've mastered that you can browse other style guides to pick up common principles and decide which one you like best.
+
+## Automated Linters
+
+Linters are tools that can automatically check the style of your code and make suggestions for refactoring.
+
+The great thing about them is that style-checking can also find some bugs, like typos in variable or function names. Because of this feature, installing a linter is recommended even if you don't want to stick to one particular "code style".
+
+Here are the most well-known linting tools:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - [JSLint](http://www.jslint.com/) -- 第一批 linters 之一。
 - [JSHint](http://www.jshint.com/) -- 比 JSLint 多了更多设置。
@@ -288,15 +403,28 @@ function pow(x, n) {
 
 它们都能够做这些工作。笔者使用 [ESLint](http://eslint.org/).
 
+<<<<<<< HEAD
 大多数 linters 都可以与编辑器集成在一起：只需在编辑器中启用插件并配置风格即可。
+=======
+Most linters are integrated with many popular editors: just enable the plugin in the editor and configure the style.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如，要使用 ESLint 你应该这样做：
 
+<<<<<<< HEAD
 1. 安装 [Node.JS](https://nodejs.org/).
 2. 使用 `npm install -g eslint` 命令（npm 是 Node.JS 的包安装工具）安装 ESLint。
 3. 在你项目的根目录（包含你所有文件的那个目录）创建一个名叫 `.eslintrc` 的配置文件。
 
 这有一个 `.eslintrc` 的例子：
+=======
+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.
+
+Here's an example of an `.eslintrc` file:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 {
@@ -313,6 +441,7 @@ function pow(x, n) {
 }
 ```
 
+<<<<<<< HEAD
 这里的 `"extends"` 指令表示我们是基于 "eslint:recommended" 的设置项而进行设置的，并且我们还制定了我们自己的规则。
 
 在你的编辑器中安装 / 启用插件以和 ESLint 集成。大多数编辑都有的。
@@ -324,11 +453,26 @@ function pow(x, n) {
 因此即使你不关心风格，也推荐你使用一个 linter。
 
 某些 IDE 还支持内置的 linting，但不像 ESLint 那么灵活可配置。
+=======
+Here the directive `"extends"` denotes that the configuration is based on the "eslint:recommended" set of settings. After that, we specify our own.
+
+It is also possible to download style rule sets from the web and extend them instead. See <http://eslint.org/docs/user-guide/getting-started> for more details about installation.
+
+Also certain IDEs have built-in linting, which is convenient but not as customizable as ESLint.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 总结
 
+<<<<<<< HEAD
 本章的所有语法规则和样式指南旨在提高可读性，因此所有的内容都是值得商榷的。
 
 当我们思考“如何写地更好”的时候，唯一的标准是“什么会让代码更加可读和容易理解，什么会帮助我们避免错误”。这是当选择一种风格或讨论哪一种更好的时候要牢记的主要原则。
 
 阅读风格指南，以查看相关的最新想法，并遵循那些你发现的最好的。
+=======
+All syntax rules described in this chapter (and in the style guides referenced) aim to increase the readability of your code, but all of them are debatable.
+
+When we think about writing "better" code, the questions we should ask are, "What makes the code more readable and easier to understand?" and "What can help us avoid errors?" These are the main things to keep in mind when choosing and debating code styles.
+
+Reading popular style guides will allow you to keep up to date with the latest ideas about code style trends and best practices.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 278fd294cf..1c6d355dd5 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 b576143455..832623d9c1 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 112c2803ed..b04db65c67 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 ce6e75c4dd..0e994ca4b3 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/03-comments/article.md b/1-js/03-code-quality/03-comments/article.md
index c83bac1011..7f5609a3ae 100644
--- a/1-js/03-code-quality/03-comments/article.md
+++ b/1-js/03-code-quality/03-comments/article.md
@@ -162,7 +162,11 @@ function addJuice(container) {
 
 ## 总结
 
+<<<<<<< HEAD
 一个好的开发者的标志之一就是他的注释：它们的存在甚至它们的缺席。
+=======
+An important sign of a good developer is comments: their presence and even their absence.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 好的注释可以使我们更好的维护代码，并且在很长时间之后依然可以更高效地回到代码中和使用其功能。
 
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 2f9b55d219..58f6c6be16 100644
--- a/1-js/03-code-quality/04-ninja-code/article.md
+++ b/1-js/03-code-quality/04-ninja-code/article.md
@@ -5,7 +5,11 @@
 学而不思则罔，思而不学则殆。
 ```
 
+<<<<<<< HEAD
 过去的程序员忍者使用这些技巧来使代码维护者的头脑更加敏锐。
+=======
+Programmer ninjas of the past used these tricks to sharpen the mind of code maintainers.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 代码审查大师在测试任务中寻找它们。
 
@@ -32,9 +36,15 @@
 i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
 ```
 
+<<<<<<< HEAD
 很酷，对吗？如果你这样写了，那些看到这一行代码并尝试去理解 `i` 的值是什么的开发者们就会有一个“快活的”的时光了。然后会来找你寻求答案。
 
 告诉他短一点总是更好的。引导他进入忍者之路。
+=======
+Cool, right? If you write like that, a developer who comes across this line and tries to understand what is the value of `i` is going to have a merry time. Then come to you, seeking for an answer.
+
+Tell them that shorter is always better. Initiate them into the paths of ninja.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 一个字母的变量
 
@@ -44,11 +54,19 @@ i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
 
 编码更快（也更糟糕）的另一种方式是到处使用单字母的变量名。像是 `a`、`b` 或 `c`。
 
+<<<<<<< HEAD
 短变量会像森林中真正的忍者一样在代码中消失不见。没有人能够通过编辑器的“搜索”找到它。即使有人做到了，他也不能“破译”出变量名 `a` 或 `b` 是什么意思。
+=======
+A short variable disappears in the code like a real ninja in the forest. No one will be able to find it using "search" of the editor. And even if someone does, they won't be able to "decipher" what the name `a` or `b` means.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ...但是有一个例外情况。一个真正的忍者绝不会在 `"for"` 循环中使用 `i` 作为计数器。在任何地方都可以，但是这里不会用。看一下四周吧，还有很多不常用的字母呢。例如 `x` 或 `y`。
 
+<<<<<<< HEAD
 如果循环体能够达到 1-2 页（如果可以的话可以让它更长）那么长的话，使用一个不常用的变量作为循环的计数器就更酷了。如果某人看到循环内部的深处后，他就不能很快地找出变量 `x` 是循环计数器啦。
+=======
+An exotic variable as a loop counter is especially cool if the loop body takes 1-2 pages (make it longer if you can). Then if someone looks deep inside the loop, they won't be able to quickly figure out that the variable named `x` is the loop counter.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 使用缩写
 
@@ -82,7 +100,11 @@ i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
 
     尝试一下吧。新手可能会诧异 —— 这些名字对于忍者来说真的有用吗？事实上，是的！
 
+<<<<<<< HEAD
     一方面，变量名仍然有着一些含义。它说明了变量内是什么：一个字符串、一个数字或是其他的东西。但是当一个局外人试图理解代码时，他会惊讶地发现实际上没有任何有效信息！最终无法改变你精心思考过的代码。
+=======
+    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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     事实上，值的类型很容易就能通过调试看出来。但是变量名的含义呢？它存了哪一个字符串/数字？
 
@@ -152,9 +174,15 @@ function ninjaFunction(elem) {
 }
 ```
 
+<<<<<<< HEAD
 想要在第二部分中使用 `elem` 的程序员会非常的诧异滴...只有在调试期间，在检查代码之后，他会发现他正在使用克隆过的变量！
 
 经常看到这样的代码，即使对经验丰富的忍者来说也是致命的。
+=======
+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. 
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 下划线的乐趣
 
@@ -170,7 +198,13 @@ function ninjaFunction(elem) {
 
 事实上，从一方面来说，看似写了一些东西：`super..`、`mega..`、`nice..`，但是从另一方面来说 —— 并没有提供任何细节。读者可能要寻找一个隐藏的含义或深思一两个小时。
 
+<<<<<<< HEAD
 ## 重叠外部变量
+=======
+
+
+## Overlap outer variables
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```quote author="关尹子"
 处明者不见暗中一物<br>，
@@ -194,7 +228,11 @@ function render() {
 
 跳过 `render` 的程序员可能不会注意到有一个本地 `user` 遮挡外部的 `user` 了。
 
+<<<<<<< HEAD
 然后他会假设 `user` 仍然是外部的变量然后使用它，`authenticateUser()` 的结果... 陷阱出来啦！你好呀，调试器...
+=======
+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...
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 
 ## 无处不在的副作用！
@@ -203,7 +241,11 @@ function render() {
 
 **一个非常好的技巧 - 除了主要任务之外，还要向它们添加一个“有用的”动作**
 
+<<<<<<< HEAD
 当你的同事看到被命名为 `is..`、`check..` 或 `find...` 的函数改变了某些东西的时候，他的脸上肯定是一脸懵逼的状态。
+=======
+An expression of dazed surprise on the face of your colleague when they see a function named `is..`, `check..` or `find...` changing something -- will definitely broaden your boundaries of reason.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 **另一种惊喜的方式是返回非标准的结果。**
 
@@ -226,7 +268,11 @@ function render() {
 
 **将多个动作加入到一起可以保护您的代码避免重用。**
 
+<<<<<<< HEAD
 想象一下，另一个开发者只想检查邮箱而不想输出任何信息。你的函数 `validateEmail(email)` 对他而言就不合适啦。所以他不会找你问一些关于这些函数的事情从而打断你的思考。
+=======
+Imagine, another developer wants only to check the email, and not output any message. Your function  `validateEmail(email)` that does both will not suit them. So they won't break your meditation by asking anything about it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 总结
 
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 988534045f..5601291113 100644
--- a/1-js/03-code-quality/05-testing-mocha/article.md
+++ b/1-js/03-code-quality/05-testing-mocha/article.md
@@ -96,7 +96,11 @@ describe("pow", function() {
 ```html src="index.html"
 ```
 
+<<<<<<< HEAD
 该页面可分为四部分：
+=======
+The page can be divided into five parts:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 1. `<head>` -- 为测试添加第三方库和样式文件。
 2. `<script>` 包含测试函数，在我们的例子中 --和 `pow` 相关的代码。
@@ -117,8 +121,13 @@ describe("pow", function() {
 为了可以通过测试，让我们来简单的实现一下 `pow`：
 
 ```js
+<<<<<<< HEAD
 function pow() {
   return 8; // :) 我们作弊啦！
+=======
+function pow(x, n) {
+  return 8; // :) we cheat!
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 }
 ```
 
@@ -233,7 +242,7 @@ describe("pow", function() {
 describe("pow", function() {
 
 *!*
-  describe("raises x to power n", function() {
+  describe("raises x to power 3", function() {
 */!*
 
     function makeTest(x) {
@@ -296,7 +305,11 @@ Testing finished – after all tests (after)
 
 [edit src="beforeafter" title="Open the example in the sandbox."]
 
+<<<<<<< HEAD
 通常地，`beforeEach/afterEach` (`before/each`) 用于初始化，清零计数器或做一些介于每个测试（或测试组）之间的事情。
+=======
+Usually, `beforeEach/afterEach` (`before/after`) are used to perform initialization, zero out counters or do something else between the tests (or test groups).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ````
 
 ## 延伸的规范
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 d82a79dca2..e8d6be23d5 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 10a032d03a..e5ce2ce433 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 a5a3459795..75ff5e99fd 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 a5a3459795..75ff5e99fd 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/03-code-quality/06-polyfills/article.md b/1-js/03-code-quality/06-polyfills/article.md
index 4dfc4de49b..6bb97796da 100644
--- a/1-js/03-code-quality/06-polyfills/article.md
+++ b/1-js/03-code-quality/06-polyfills/article.md
@@ -19,21 +19,38 @@ JavaScript 引擎背后的团队关于首先要实现什么有着他们自己想
 
 实际上，Babel 包含了两部分：
 
+<<<<<<< HEAD
 1. 第一，transpiler 程序，就是重写代码的那个。开发者在他自己的电脑上运行它。它将代码重写到旧的标准中。然后将代码交付给用户的网站。诸如 [webpack](http://webpack.github.io/) 或 [brunch](http://brunch.io/) 这样的现代项目构建系统提供了每当代码改变都会自动运行 transpiler 的方法，因此我们这边没有任何的时间损失。
+=======
+1. First, the transpiler program, which rewrites the code. The developer runs it on their own computer. It rewrites the code into the older standard. And then the code is delivered to the website for users. Modern project build system like [webpack](http://webpack.github.io/) provide means to run transpiler automatically on every code change, so that very easy to integrate into development process.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 2. 第二，polyfill。
 
+<<<<<<< HEAD
     transpiler 会重写代码，因此现有的语法特性都被覆盖了。但是对于新特性我们需要写一个特殊的脚本来实现它们。JavaScript 是一个高度动态化的语言。脚本可能不仅是添加一些新特性，还会修改一些内置特性，以便于它们表现得符合现代标准。
 
     脚本有一个术语 "polyfill" 表示用来“填补”缺口并添加缺少的实现。
+=======
+    New language features may include new built-in functions and syntax constructs.
+    The transpiler rewrites the code, transforming syntax constructs into older ones. But as for new built-in functions, we need to implement them. JavaScript is a highly dynamic language, scripts may add/modify any functions, so that they behave according to the modern standard.
+
+    A script that updates/adds new functions is called "polyfill". It "fills in" the gap and adds missing implementations.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     两个有意思的 polyfills 是：
     - [babel polyfill](https://babeljs.io/docs/usage/polyfill/) 支持很多，但是很大。
     - [polyfill.io](http://polyfill.io) 服务允许我们能根据自己所需的特性来按需加载、构建 polyfill。
 
+<<<<<<< HEAD
 因此，我们需要为那些旧引擎设置 transpiler 并添加 polyfill 来支持现代特性。
 
 如果我们的目标是现代引擎，并且整个项目不使用其他地方不支持的特性，那么我们就不需要使用 Babel。
+=======
+So, if we're going to use modern language features, a transpiler and a polyfill are necessary.
+
+## Examples in the tutorial
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 教程中的案例
 
@@ -48,9 +65,16 @@ alert('Press the "Play" button in the upper-right corner to run');
 ````
 
 ```offline
+<<<<<<< HEAD
 当你正在阅读离线版本时，例子是不可运行的。但是它们通常是可以工作的。:)
 ```
 
 [Chrome Canary](https://www.google.com/chrome/browser/canary.html) 适用于所有示例，但其他现代浏览器大多数也都很好。
 
 需要注意的是，在生产环境中我们可以用 Babel 来将代码转换为适合少数近代浏览器的代码，所以它们没有这样的限制，代码会在任何地方运行。
+=======
+As you're reading the offline version, in PDF examples are not runnable. In EPUB some of them can run.
+```
+
+Google Chrome is usually the most up-to-date with language features, good to run bleeding-edge demos without any transpilers, but other modern browsers also work fine.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 4bec82dd37..08089f6dba 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,11 @@
 function isEmpty(obj) {
   for (let key in obj) {
+<<<<<<< HEAD
     // 如果进到循环里面，说明有属性。
+=======
+    // if the loop has started, there is a property
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
     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 663c81b3fd..7d53fd7375 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
 遍历一个对象，如果对象存在任何属性则 `return false`。
 
 ```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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/1-js/04-object-basics/01-object/4-const-object/task.md b/1-js/04-object-basics/01-object/4-const-object/task.md
index a2997a1304..46e62472d1 100644
--- a/1-js/04-object-basics/01-object/4-const-object/task.md
+++ b/1-js/04-object-basics/01-object/4-const-object/task.md
@@ -4,7 +4,11 @@ importance: 5
 
 # 不可变对象
 
+<<<<<<< HEAD
 有可能改变 `const` 修饰的对象吗, 你怎么看呢？
+=======
+Is it possible to change an object declared with `const`? What do you think?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 const user = {
diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index 7153f2b71c..ca96f297fd 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -1,8 +1,12 @@
 
 # 对象
 
+<<<<<<< HEAD
 正如我们从《引言：类型》那章中知道的那样，JavaScript 中有七种数据类型。有六种原始类型，因为他们的值只包含一种东西（字符串，数值或者其他）。
 相反，对象用来存储键值对和更复杂的实体。在 JavaScript 中，对象深入到这门语言的方方面面。所以在我们深入理解这门语言之前，必须先理解对象。
+=======
+As we know from the chapter <info:types>, there are seven data types in JavaScript. Six of them are called "primitive", because their values contain only a single thing (be it a string or a number or whatever).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 对象可以通过花括号 `{…}` 和其中包含一些可选的**属性**来创建。属性是一个键值对，键是一个字符串（也叫做属性名），值可以是任何类型。
 
@@ -201,7 +205,7 @@ let obj = {
   for: 1,
   let: 2,
   return: 3
-}
+};
 
 alert( obj.for + obj.let + obj.return );  // 6
 ```
@@ -216,12 +220,22 @@ alert(obj.__proto__); // [object Object]，这样不行
 
 我们从代码中可以看出来，把它赋值成 `5` 被忽略了。
 
+<<<<<<< HEAD
 如果我们蓄意去存储随机的键值对或者允许一个访问者去指定键，那可能就会产生很多 bug 并且使对象变得危险。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 比如，访问者可能选择 "__proto__" 作为键，这个赋值的逻辑就失败了（像上面那样）。
 
+<<<<<<< HEAD
 有一种让对象把 `__proto__` 作为属性的方法，在后面章节会讲到，现在我们先来学习对象的更多知识。
 还有另外一种数据结构 [Map](info:map-set-weakmap-weakset)，我们会在后面章节学到，它支持任意的键值。
+=======
+There is a way to make objects treat `__proto__` as a regular property, which we'll cover later, but first we need to know more about objects.
+There's also another data structure [Map](info:map-set-weakmap-weakset), that we'll learn in the chapter <info:map-set-weakmap-weakset>, which supports arbitrary keys.
+````
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ````
 
@@ -295,7 +309,13 @@ alert( "age" in user ); // true，user.age 存在
 alert( "blabla" in user ); // false，user.blabla 不存在。
 ```
 
+<<<<<<< HEAD
 注意 `in` 的左边必须是**属性名**。通常是一个字符串，如果不用字符串，那就是一个字符串变量。
+=======
+Please note that on the left side of `in` there must be a *property name*. That's usually a quoted string.
+
+If we omit quotes, that would mean a variable containing the actual name will be tested. For instance:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let user = { age: 30 };
@@ -333,8 +353,13 @@ alert( "test" in obj ); // true，属性存在！
 语法：
 
 ```js
+<<<<<<< HEAD
 for(key in object) {
   // 各个属性键值的执行区
+=======
+for (key in object) {
+  // executes the body for each key among object properties
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 }
 ```
 
@@ -347,7 +372,7 @@ let user = {
   isAdmin: true
 };
 
-for(let key in user) {
+for (let key in user) {
   // keys
   alert( key );  // name, age, isAdmin
   // 属性键的值
@@ -355,7 +380,13 @@ for(let key in user) {
 }
 ```
 
+<<<<<<< HEAD
 注意，所有的 "for" 都允许我们在循环中定义变量，像 `let key` 这样。
+=======
+Note that all "for" constructs allow us to declare the looping variable inside the loop, like `let key` here.
+
+Also, we could use another variable name here instead of `key`. For instance, `"for (let prop in obj)"` is also widely used.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 同样，我们可以用其他属性名来代替 `key`。例如 `"for(let prop in obj)"` 也很常用。
 
@@ -377,7 +408,7 @@ let codes = {
 };
 
 *!*
-for(let code in codes) {
+for (let code in codes) {
   alert(code); // 1, 41, 44, 49
 }
 */!*
@@ -435,7 +466,7 @@ let codes = {
   "+1": "USA"
 };
 
-for(let code in codes) {
+for (let code in codes) {
   alert( +code ); // 49, 41, 44, 1
 }
 ```
@@ -598,8 +629,13 @@ for (let key in user) {
 }
 */!*
 
+<<<<<<< HEAD
 // 现在复制是独立的复制了
 clone.name = "Pete"; // 改变它的值
+=======
+// now clone is a fully independent clone
+clone.name = "Pete"; // changed the data in it
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 alert( user.name ); // 原对象属性值不变
 ```
@@ -609,7 +645,7 @@ alert( user.name ); // 原对象属性值不变
 语法是：
 
 ```js
-Object.assign(dest[, src1, src2, src3...])
+Object.assign(dest, [src1, src2, src3...])
 ```
 
 - 参数 `dest` 和 `src1, ..., srcN`（可以有很多个）是对象。
@@ -692,7 +728,14 @@ user.sizes.width++;       // 在这里改变一个属性的值
 alert(clone.sizes.width); // 51，在这里查看属性的值
 ```
 
+<<<<<<< HEAD
 为了解决上面的的问题，我们在复制的时候应该检查 `user[key]` 的每一个值，如果是一个对象，我们再复制一遍这个对象，这叫做深拷贝。
+=======
+To fix that, we should use the cloning loop that examines each value of `user[key]` and, if it's an object, then replicate its structure as well. That is called a "deep cloning".
+
+There's a standard algorithm for deep cloning that handles the case above and more complex cases, called the [Structured cloning algorithm](http://w3c.github.io/html/infrastructure.html#safe-passing-of-structured-data). In order not to reinvent the wheel, we can use a working implementation of it from the JavaScript library [lodash](https://lodash.com), the method is called [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep).
+
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 有一个标准的深拷贝算法，解决上面和一些更复杂的情况，叫做 [Structured cloning algorithm](https://w3c.github.io/html/infrastructure.html#internal-structured-cloning-algorithm)。为了不重复造轮子，我们使用它的一个 JS 实现的库 [lodash](https://lodash.com), 方法名叫做 [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep)。
 
@@ -708,10 +751,17 @@ alert(clone.sizes.width); // 51，在这里查看属性的值
 - 点符号: `obj.property`。
 - 方括号 `obj["property"]`，方括号中可以使用变量 `obj[varWithKey]`。
 
+<<<<<<< HEAD
 其他操作：
 - 删除属性：`delete obj.prop`。
 - 检查属性是否存在：`"key" in obj`。
 - 遍历对象：`for(let key in obj)` 循环。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 对象根据引用来赋值或者复制。换句话说，变量存的不是对象的"值"，而是值的 "引用"（内存地址）。 
 所以复制变量或者传递变量到方法中只是复制了对象的引用。
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 688158f9b0..8702675c81 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 e1ef655414..698766bb0a 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 483d072c6d..6b1f27a690 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 8db894cb3b..5f261eca41 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 4e76eeb76a..2ce66a49d3 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 b409776903..4a15dac64b 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 2bfdfabdb3..b0486e900e 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 4935b59ce8..20859fe911 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 16179209f3..6215b82079 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 7203895324..c66fa5159b 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 f94d094a96..a853c9c393 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 003c2f6eab..12011ff5c7 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 d6e7fddff6..cdd53d0b2d 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 145bad29af..0701261980 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 97510c4b21..2870858420 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 a64238a52b..e7b994c534 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 e21af09907..c360a0e132 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 2f0b2f47d4..323bc46224 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/article.md b/1-js/04-object-basics/02-garbage-collection/article.md
index 79a63115d2..6c8295205b 100644
--- a/1-js/04-object-basics/02-garbage-collection/article.md
+++ b/1-js/04-object-basics/02-garbage-collection/article.md
@@ -207,6 +207,10 @@ JavaScript 引擎做了许多优化，使其运行速度更快，并且不会影
 
 如果你熟悉低级编程，关于 V8 引擎垃圾回收器的更详细信息请参阅文章 [V8 的垃圾回收：垃圾回收](http://jayconrod.com/posts/55/a-tour-of-v8-garbage-collection)。
 
+<<<<<<< HEAD
 [V8 博客](http://v8project.blogspot.com/)还不时发布关于内存管理变化的文章。当然，为了学习垃圾收集，你最好通过学习 V8 引擎内部知识来进行准备，并阅读一个叫 [Vyacheslav Egorov](http://mrale.ph) 的 V8 引擎工程师的博客。我之所以说『V8』，因为它最容易在互联网上找到文章。对于其他引擎，许多方法是相似的，但在垃圾收集上许多方面有所不同。
+=======
+[V8 blog](https://v8.dev/) also publishes articles about changes in memory management from time to time. Naturally, to learn the garbage collection, you'd better prepare by learning about V8 internals in general and read the blog of [Vyacheslav Egorov](http://mrale.ph) who worked as one of V8 engineers. I'm saying: "V8", because it is best covered with articles in the internet. For other engines, many approaches are similar, but garbage collection differs in many aspects.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 当你需要低级别的优化时，对引擎的深入了解是很好的。在熟悉了该语言之后，把熟悉引擎作为下一步是明智的。
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 5c10f0e47e..05160890e2 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 24d29630e5..a92fc573b6 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 a4ce30a354..e60f9b88d8 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 0d9949839e..7549037060 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 e24dba5b57..823d0a618c 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 a6c4ee36a3..9e100d522a 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 df14624bc0..5ddb6f68ff 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 5ab4b37920..868c748a06 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 dbbc01d2f5..f37464e6c5 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 64b4619ba1..4f5d47210d 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 423191778e..5cfe664c35 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 223ea32a12..cf93a1605e 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 da63d39693..2bbe4241d4 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 1f614e3e6d..f4a7abb526 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 e77144c1d7..665a22784f 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 37e349b627..60d4059cca 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 110e0d9c4b..4ba6e17ecc 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 c09d75f9d1..8ac09c80d6 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 bc4ea9670e..35c8816dcb 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 0ab697e683..4db0c1732e 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 29c4fcbea8..9ddac3e299 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 2f80f19a21..9069781f24 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 cdc1d49049..ae1684b2d2 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 d58afdb582..c510380f9e 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 3ba5730de9..2ad00b6cb1 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 5aa81bb0c0..f365ac0365 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 59a2de6116..bac44f39a1 100644
--- a/1-js/04-object-basics/03-symbol/article.md
+++ b/1-js/04-object-basics/03-symbol/article.md
@@ -18,8 +18,13 @@ let id = Symbol();
 
 我们可以给 Symbol 一个描述（也称为 Symbol 名），这对于调试非常有用：
 
+<<<<<<< HEAD
 ```js
 // id 是描述为 "id" 的 Symbol
+=======
+```js run
+// id is a symbol with the description "id"
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 let id = Symbol("id");
 ```
 
@@ -50,7 +55,13 @@ alert(id); // 类型错误：无法将 Symbol 值转换为 String。
 */!*
 ```
 
+<<<<<<< HEAD
 如果我们真的想显示一个 Symbol，我们需要在它上面调用 `.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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```js run
 let id = Symbol("id");
 *!*
@@ -58,7 +69,18 @@ alert(id.toString()); // Symbol(id)，现在它起作用了
 */!*
 ```
 
+<<<<<<< HEAD
 这是一种防止混乱的“语言保护”，因为 String 和 Symbol 有本质上的不同，而且不应该偶尔将它们相互转化。
+=======
+Or get `symbol.description` property to get the description only:
+```js run
+let id = Symbol("id");
+*!*
+alert(id.description); // id
+*/!*
+```
+
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ````
 
 ## “隐藏”属性
@@ -75,7 +97,11 @@ user[id] = "ID Value";
 alert( user[id] ); // 我们可以使用 Symbol 作为键来访问数据。
 ```
 
+<<<<<<< HEAD
 在 string `"id"` 上使用 `Symbol("id")` 有什么好处？ 
+=======
+What's the benefit of using `Symbol("id")` over a string `"id"`?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 我们用更深入一点的示例来说明这一点。
 
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 22c4bf187c..459997624e 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 a19f7a77bd..db268a8fa0 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 @@
 解决方案就是在每次调用后返回这个对象本身。
 
-```js run
+```js run demo
 let ladder = {
   step: 0,
   up() {
@@ -28,7 +28,7 @@ ladder.up().up().down().up().down().showStep(); // 1
 
 我们也可以每行一个调用。对于长链接它更具可读性：
 
-```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 2d37bf4eb5..788e5c590d 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
 修改 `up` 和 `down` 的代码让调用可以链接，就像这样：
+=======
+Modify the code of `up`, `down` and `showStep` to make the calls chainable, like this:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```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 8beb5b17b8..fc0a520106 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="Object-oriented programming"
 当我们在代码中用对象表示实体时，这就是所谓的[面向对象编程](https://en.wikipedia.org/wiki/Object-oriented_programming)，简称为 "OOP"。
 
+<<<<<<< HEAD
 OOP 是一门很大的学问，也是一门有其本身乐趣的学问。怎样选择合适的实体？如何组织它们之间的交互？这就是架构，有很多关于此方面的书，例如 E.Gamma、R.Helm、R.Johnson 和 J.Vissides 所著的《设计模式：可复用面向对象软件的基础》、G.Booch 所著的《面向对象分析与设计》等等。在后面的 <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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 ### 方法简写
 
@@ -72,14 +76,19 @@ OOP 是一门很大的学问，也是一门有其本身乐趣的学问。怎样
 ```js
 // 这些对象作用一样
 
-let user = {
+user = {
   sayHi: function() {
     alert("Hello");
   }
 };
 
+<<<<<<< HEAD
 // 方法简写看起来更好，对吧？
 let user = {
+=======
+// method shorthand looks better, right?
+user = {
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 *!*
   sayHi() { // 与 "sayHi: function()" 一样
 */!*
@@ -166,7 +175,11 @@ admin.sayHi(); // 噢哟！在 sayHi() 使用了旧的变量名。错误！
 
 ## “this” 不受限制
 
+<<<<<<< HEAD
 在 JavaScript 中，"this" 关键字与大多数其他编程语言中的不同。首先，它可以用于任何函数。
+=======
+In JavaScript, "this" keyword behaves unlike most other programming languages. It can be used in any function.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这样的代码没有语法错误：
 
@@ -176,9 +189,15 @@ function sayHi() {
 }
 ```
 
+<<<<<<< HEAD
 `this` 是在运行时求值的。它可以是任何值。
 
 例如，从不同的对象中调用同一个函数可能会有不同的 "this" 值：
+=======
+The value of `this` is evaluated during the run-time, depending on the context. And it can be anything.
+
+For instance, here the same function is assigned to two different objects and has different "this" in the calls:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let user = { name: "John" };
@@ -189,7 +208,11 @@ function sayHi() {
 }
 
 *!*
+<<<<<<< HEAD
 // 在两个对象中使用的是相同的函数
+=======
+// use the same function in two objects
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 user.f = sayHi;
 admin.f = sayHi;
 */!*
@@ -202,7 +225,14 @@ admin.f(); // Admin  (this == admin)
 admin['f'](); // Admin（使用点或方括号语法来访问这个方法，都没有关系。）
 ```
 
+<<<<<<< HEAD
 实际上，我们可以在没有任何对象的情况下调用函数：
+=======
+The rule is simple: if `obj.f()` is called, then `this` is `obj` during the call of `f`. So it's either `user` or `admin` in the example above.
+
+````smart header="Calling without an object: `this == undefined`"
+We can even call the function without an object at all:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 function sayHi() {
@@ -214,9 +244,16 @@ sayHi(); // undefined
 
 在这种情况下，严格模式下的 `this` 值为 `undefined`。如果我们尝试访问 `this.name`，将会出现错误。
 
+<<<<<<< HEAD
 在非严格模式（没有使用 `use strict`）的情况下，`this` 将会是**全局对象**（浏览器中的 `window`，我们稍后会进行讨论）。`"use strict"` 可以修复这个历史行为。
 
 请注意，通常在没有对象的情况下使用 `this` 的函数调用是不常见的，会（导致）编程错误。如果函数中有 `this`，那么通常意味着它是在对象上下文环境中被调用的。
+=======
+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.
+
+Usually such call is an programming error. If there's `this` inside a function, it expects to be called in an object context.
+````
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```smart header="The consequences of unbound `this`"
 如果你来自其他的编程语言，那么你可能熟悉『绑定 `this`』的概念。在对象定义的方法中，`this` 总是指向该对象。
@@ -257,7 +294,11 @@ user.hi(); // John (the simple call works)
 
 该方法立即被括号 `()` 调用。但它无效。
 
+<<<<<<< HEAD
 你可以看到该调用导致了错误，因为调用中的 `"this"` 为 `undefined`。
+=======
+You can see that the call results in an error, because the value of `"this"` inside the call becomes `undefined`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这样是正确的（对象点方法）：
 ```js
@@ -276,7 +317,11 @@ user.hi();
 1. 首先，点 `'.'` 取得这个 `obj.method` 属性。
 2. 其后的括号 `()` 调用它。
 
+<<<<<<< HEAD
 那么，`this` 是如何从第一部分传递到第二部分的呢？
+=======
+So, how does the information about `this` get passed from the first part to the second one?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如果把这些操作分离开，那么 `this` 肯定会丢失：
 
@@ -312,11 +357,19 @@ hi(); // 错误，因为 this 未定义
 (user, "hi", true)
 ```
 
+<<<<<<< HEAD
 当在引用类型上用 `()` 调用时，它们接收到这个对象和它的方法的所有信息，并且设定正确的 `this` 值（这里等于 `user`）。
+=======
+When parentheses `()` are called on the Reference Type, they receive the full information about the object and its method, and can set the right `this` (`=user` in this case).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `hi = user.hi` 赋值等其他的操作，将引用类型作为一个整体丢弃，只获取 `user.hi`（一个函数）的值进行传递。因此，进一步操作『失去』了 `this`（值）。
 
+<<<<<<< HEAD
 所以如果直接使用点 `obj.method()` 或方括号语法 `obj[method]()`（它们在这里并无差别）调用函数，那么作为结果，`this` 值会以正确的方式进行传递。
+=======
+So, as the result, the value of `this` is only passed the right way if the function is called directly using a dot `obj.method()` or square brackets `obj['method']()` syntax (they do the same here). Later in this tutorial, we will learn various ways to solve this problem such as [func.bind()](/bind#solution-2-bind).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 箭头函数没有自己的 "this"
 
diff --git a/1-js/04-object-basics/05-object-toprimitive/article.md b/1-js/04-object-basics/05-object-toprimitive/article.md
index 81b2d76bc0..3e13922822 100644
--- a/1-js/04-object-basics/05-object-toprimitive/article.md
+++ b/1-js/04-object-basics/05-object-toprimitive/article.md
@@ -3,6 +3,7 @@
 
 当对象相加 `obj1 + obj2`，相减 `obj1 - obj2`，或者使用 `alert(obj)` 打印时会发生什么？
 
+<<<<<<< HEAD
 在对象中有特殊的方法用来做转换。
 
 在 <info:type-conversions> 一章中，我们已经看到了数值，字符串和布尔转换的规则。但是我们给对象的原始值转换留下了一点疑问。正如我们所知道的方法和符号一样，现在我们可以解决这个问题了。
@@ -20,11 +21,30 @@
 该算法允许我们使用特殊的对象方法自定义转换。
 
 取决于上下文，转换具有所谓的“暗示”。
+=======
+In that case objects are auto-converted to primitives, and then the operation is carried out.
+
+In the chapter <info:type-conversions> we've seen the rules for numeric, string and boolean conversions of primitives. But we left a gap for objects. Now, as we know about methods and symbols it becomes possible to fill it.
+
+1. All objects are `true` in a boolean context. There are only numeric and string conversions.
+2. The numeric conversion happens when we subtract objects or apply mathematical functions. For instance, `Date` objects (to be covered in the chapter <info:date>) can be subtracted, and the result of `date1 - date2` is the time difference between two dates.
+3. As for the string conversion -- it usually happens when we output an object like `alert(obj)` and in similar contexts.
+
+## ToPrimitive
+
+We can fine-tune string and numeric conversion, using special object methods.
+
+The conversion algorithm is called `ToPrimitive` in the [specification](https://tc39.github.io/ecma262/#sec-toprimitive). It's called with a "hint" that specifies the conversion type.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这里有三种变体：
 
 `"string"`
+<<<<<<< HEAD
 : 当一个操作期望一个字符串时，对于对象到字符串的转换，比如 `alert`：
+=======
+: For an object-to-string conversion, when we're doing an operation on an object that expects a string, like `alert`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js
     // output
@@ -35,7 +55,11 @@
     ```
 
 `"number"`
+<<<<<<< HEAD
 : 当一个操作需要一个数字时，用于对象到数字的转换，如 `maths`：
+=======
+: For an object-to-number conversion, like when we're doing maths:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js
     // 显式转换
@@ -52,7 +76,11 @@
 `"default"`
 : 在少数情况下发生，当操作者“不确定”期望的类型时。
 
+<<<<<<< HEAD
     例如，二进制加 `+` 可以和字符串（连接）和数字（相加）发生作用，所以类型是字符串和数字都可以。或者当一个对象用 `==` 与一个字符串、数字或符号进行比较时。
+=======
+    For instance, binary plus `+` can work both with strings (concatenates them) and numbers (adds them), so both strings and numbers would do. Or when an object is compared using `==` with a string, number or a symbol, it's also unclear which conversion should be done.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js
     // 二进制加
@@ -159,14 +187,30 @@ alert(user + 500); // toString -> John500
 
 如果没有 `Symbol.toPrimitive` 和 `valueOf`，`toString` 将处理所有原始转换。
 
+<<<<<<< HEAD
 
 ## ToPrimitive 和 ToString/ToNumber
+=======
+## Return types
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 关于所有原始转换方法，有一个重要的点需要知道，就是它们不一定会返回“暗示的”原始值。
 
 没有限制 `toString()` 是否返回字符串，或 `Symbol.toPrimitive` 方法是否为 "number" 暗示返回数字。
 
+<<<<<<< HEAD
 **唯一强制性的事情是：这些方法必须返回一个原始值。**
+=======
+The only mandatory thing: these methods must return a primitive, not an object.
+
+```smart header="Historical notes"
+For historical reasons, if `toString` or `valueOf` returns an object, there's no error, but such value is ignored (like if the method didn't exist). That's because in ancient times there was no good "error" concept in JavaScript.
+
+In contrast, `Symbol.toPrimitive` *must* return a primitive, otherwise there will be an error.
+```
+
+## Further operations
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 发起转换的操作获取该原始值，然后继续使用该原始值，并在必要时应用进一步的转换。
 
@@ -208,11 +252,14 @@ alert(user + 500); // toString -> John500
     alert(obj + 2); // 3 (ToPrimitive 返回布尔值，非字符串 => ToNumber)
     ```
 
+<<<<<<< HEAD
 ```smart header="历史笔记"
 由于历史原因，`toString` 或 `valueOf` 方法**应该**返回一个原始值：如果它们中的任何一个返回了一个对象，虽然不会报错，但是该对象被忽略（就像该方法不存在一样）。
 
 相反，`Symbol.toPrimitive` **必须**返回一个原始值，否则会出现错误。
 ```
+=======
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 概要
 
diff --git a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md
index 27978ac1f0..4da30203ab 100644
--- a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md
+++ b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md
@@ -2,7 +2,11 @@
 
 如果一个函数返回一个对象，那么 `new` 返回那个对象而不是 `this`。
 
+<<<<<<< HEAD
 所以他们可以，例如，返回相同的外部定义的对象 `obj`：
+=======
+So they can, for instance, return the same externally defined object `obj`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run no-beautify
 let obj = {};
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 e5583c5d01..86bb65416d 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 5d4b4e0208..64fff0f1a6 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -83,7 +83,15 @@ let user = new function() {
 构造函数不能被再次调用，因为它不保存在任何地方，只是被创建和调用。所以这个技巧的目的是封装构建单个对象的代码，而不是将来重用。
 ````
 
+<<<<<<< HEAD
 ## 双语法构造函数：new.target
+=======
+## Constructor mode test: new.target
+
+```smart header="Advanced stuff"
+The syntax from this section is rarely used, skip it unless you want to know everything.
+```
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在一个函数内部，我们可以使用 `new.target` 属性来检查它被调用时，是否使用了 `new`。
 
@@ -94,14 +102,32 @@ function User() {
   alert(new.target);
 }
 
+<<<<<<< HEAD
 // 不带 new：
+=======
+// without "new":
+*!*
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 User(); // undefined
+*/!*
 
+<<<<<<< HEAD
 // 带 new：
+=======
+// with "new":
+*!*
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 new User(); // function User { ... }
+*/!*
 ```
 
+<<<<<<< HEAD
 这可以使 `new` 和常规语法的工作原理相同：
+=======
+That can be used inside the function to know whether it was called with `new`, "in constructor mode", or without it, "in regular mode".
+
+We can also make both `new` and regular calls to do the same, like this:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 function User(name) {
@@ -116,7 +142,13 @@ let john = User("John"); // 重新调用 new User
 alert(john.name); // John
 ```
 
+<<<<<<< HEAD
 这种方法有时用在库中以使语法更加灵活。但因为省略 `new` 使得它不易阅读，这可不是一件好事。 而通过 `new` 我们可以都知道这个新对象正在创建。
+=======
+This approach is sometimes used in libraries to make the syntax more flexible. So that people may call the function with or without `new`, and it still works.
+
+Probably not a good thing to use everywhere though, because omitting `new` makes it a bit less obvious what's going on. With `new` we all know that the new object is being created.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 构造函数 Return
 
@@ -215,5 +247,9 @@ JavaScript 为许多内置的对象提供了构造函数：比如日期 Date，
 ```smart header="Objects, we'll be back!"
 在本章中，我们只介绍关于对象和构造函数的基础知识。它们对于在下一章中更多地了解数据类型和函数非常重要。
 
+<<<<<<< HEAD
 在我们了解了这一章之后 <info:object-oriented-programming> 我们返回到对象并深入其中，包括继承和类。
+=======
+After we learn that, we return to objects and cover them in-depth in the chapters <info:prototypes> and <info:classes>.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
diff --git a/1-js/05-data-types/01-primitives-methods/1-string-new-property/solution.md b/1-js/05-data-types/01-primitives-methods/1-string-new-property/solution.md
index c2be790406..7b2122dbcb 100644
--- a/1-js/05-data-types/01-primitives-methods/1-string-new-property/solution.md
+++ b/1-js/05-data-types/01-primitives-methods/1-string-new-property/solution.md
@@ -6,16 +6,23 @@ let str = "Hello";
 
 str.test = 5; // (*)
 
-alert(str.test); 
+alert(str.test);
 ```
 
+<<<<<<< HEAD
 这里有两种结果：
 
 1. `undefined`
 2. 报错。
+=======
+Depending on whether you have `use strict` or not, the result may be:
+1. `undefined` (no strict mode)
+2. An error (strict mode).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在 `(*)` 的那一行到底发生了什么呢：
 
+<<<<<<< HEAD
 1. 当访问 `str` 的属性时，创建一个“包装对象”。
 2. 当对属性进行操作的时候。这个对象获得了 `test` 属性。
 3. 操作结束，“包装对象”消失。
@@ -23,10 +30,21 @@ alert(str.test);
 在最后一行，对字符串上的新的包装对象的每个对象操作，`str` 不再追踪这个属性。
 
 一些浏览器进一步限制程序员，并且不允许将属性分配给基本类型。这就是为什么它有点远离规范，但在实践中我们却可以在 `(*)` 行看到错误。
+=======
+1. When a property of `str` is accessed, a "wrapper object" is created.
+2. In strict mode, writing into it is an error.
+3. Otherwise, the operation with the property is carried on, the object gets the `test` property, but after that the "wrapper object" disappears.
+
+So, without strict mode, in the last line `str` has no trace of the property.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 **这个例子清楚地表明，基本类型不是对象。**
 
+<<<<<<< HEAD
 基本类型不能存储数据。
 
 所有的属性/方法操作都是在临时对象的帮助下执行的。
 
+=======
+They can't store additional data.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 9912266a46..57e4e6e065 100644
--- a/1-js/05-data-types/01-primitives-methods/article.md
+++ b/1-js/05-data-types/01-primitives-methods/article.md
@@ -1,13 +1,22 @@
 # 基本类型的方法
 
+<<<<<<< HEAD
 JavaScript 允许我们像对象一样使用基本类型（字符串，数字等）。
 
 基本类型还提供调用方法等。我们会尽快研究这些，但首先我们会看看它是如何工作的，毕竟基本类型不是对象（在这里我们会分析的更加清楚）。
 
 我们来看看基本类型和对象之间的关键区别。
+=======
+JavaScript allows us to work with primitives (strings, numbers, etc.) as if they were objects.
+
+They also provide methods to call as such. We will study those soon, but first we'll see how it works because, of course, primitives are not objects (and here we will make it even clearer).
+
+Let's look at the key distinctions between primitives and objects.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 基本类型
 
+<<<<<<< HEAD
 - 是原始类型中的一种值。
 - 在 JavaScript 中有 6 种基本类型：`string`、`number`、`boolean`、`symbol`、`null` 和 `undefined`。
 
@@ -17,6 +26,17 @@ JavaScript 允许我们像对象一样使用基本类型（字符串，数字等
 - 可以使用大括号 `{}` 创建对象，例如：`{name: "John", age: 30}`。JavaScript 中还有其他种类的对象，例如函数就是对象。
 
 关于对象的最好的事情之一是我们可以存储一个函数作为它的一个属性：
+=======
+- Is a value of a primitive type.
+- There are 6 primitive types: `string`, `number`, `boolean`, `symbol`, `null` and `undefined`.
+
+An object
+
+- Is capable of storing multiple values as properties.
+- Can be created with `{}`, for instance: `{name: "John", age: 30}`. There are other kinds of objects in JavaScript: functions, for example, are objects.
+
+One of the best things about objects is that we can store a function as one of its properties.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let john = {
@@ -31,7 +51,11 @@ john.sayHi(); // Hi buddy!
 
 所以我们在这里创建了一个包含 `sayHi` 方法的对象 `john`。
 
+<<<<<<< HEAD
 许多内置对象已经存在，例如那些处理日期，错误，HTML 元素等的内置对象。它们具有不同的属性和方法。
+=======
+Many built-in objects already exist, such as those that work with dates, errors, HTML elements, etc. They have different properties and methods.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 但是，这些特性都是有成本的！
 
@@ -46,9 +70,15 @@ john.sayHi(); // Hi buddy!
 
 而解决方案看起来多少有点尴尬，如下：
 
+<<<<<<< HEAD
 1. 基本类型仍然是原始数据。如预期相同，提供单个值
 2. JavaScript 允许访问字符串，数字，布尔值和符号的方法和属性。
 3. 当进行访问时，创建一个特殊的“包装对象”，它提供额外的功能，运行后即被销毁。
+=======
+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. In order for that to work, a special "object wrapper" that provides the extra functionality is created, and then is destroyed.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 “包装对象”对于每种基本类型调用都是不同的，如`String`, `Number`, `Boolean` 和 `Symbol`。因此，他们提供了不同的方法。
 
@@ -92,18 +122,22 @@ alert( n.toFixed(2) ); // 1.23
 例如：
 
 ```js run
-alert( typeof 1 ); // "number"
+alert( typeof 0 ); // "number"
 
-alert( typeof new Number(1) ); // "object"!
+alert( typeof new Number(0) ); // "object"!
 ```
 
+<<<<<<< HEAD
 同样的，`zero`，是一个对象，alert 将显示出来：
+=======
+Objects are always truthy in `if`, so here the alert will show up:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let zero = new Number(0);
 
 if (zero) { // zero is true, because it's an object
-  alert( "zero is truthy?!?" );
+  alert( "zero is truthy!?!" );
 }
 ```
 
diff --git a/1-js/05-data-types/02-number/3-repeat-until-number/_js.view/test.js b/1-js/05-data-types/02-number/3-repeat-until-number/_js.view/test.js
index 219fa8068e..6bd0123dba 100644
--- a/1-js/05-data-types/02-number/3-repeat-until-number/_js.view/test.js
+++ b/1-js/05-data-types/02-number/3-repeat-until-number/_js.view/test.js
@@ -18,7 +18,7 @@ describe("readNumber", function() {
     assert.strictEqual(readNumber(), 0);
   });
 
-  it("continues the loop unti meets a number", function() {
+  it("continues the loop until meets a number", function() {
     prompt.onCall(0).returns("not a number");
     prompt.onCall(1).returns("not a number again");
     prompt.onCall(2).returns("1");
@@ -35,4 +35,4 @@ describe("readNumber", function() {
     assert.isNull(readNumber());
   });
 
-});
\ No newline at end of file
+});
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 562be1f62f..432e81e1c8 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 @@
 
 这可以分两个阶段完成：
 
+<<<<<<< HEAD
 1. 如果我们将 0..1 的随机数乘以 `max-min`，则可能值的间隔从 0..1 增加到 `0..max-min`。
 2. 现在，如果我们添加 `min`，则可能的间隔将从 `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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 函数实现：
 
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 8ae2b30676..cc697e70f9 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 @@ importance: 2
 功能示例：
 
 ```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
 ```
 
 您可以使用[上一个任务](info:task/random-min-max)的解决方案作为基础。
diff --git a/1-js/05-data-types/02-number/article.md b/1-js/05-data-types/02-number/article.md
index 9c7d1a830b..4301e67432 100644
--- a/1-js/05-data-types/02-number/article.md
+++ b/1-js/05-data-types/02-number/article.md
@@ -1,6 +1,10 @@
 # 数字类型
 
+<<<<<<< HEAD
 JavaScript 中的所有数字都以 64 位格式 [IEEE-754](http://en.wikipedia.org/wiki/IEEE_754-1985) 存储，也称为“双精度”。
+=======
+All numbers in JavaScript are stored in 64-bit format [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754-2008_revision), also known as "double precision floating point numbers".
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 让我们回顾一下并展开我们目前了解的内容。
 
@@ -26,11 +30,16 @@ alert( 7.3e9 );  // 7.3 billions (7,300,000,000)
 
 ```js
 1e3 = 1 * 1000
-1.23e6 = 1.23 * 1000000 
+1.23e6 = 1.23 * 1000000
 ```
 
 
+<<<<<<< HEAD
 现在让我们写一些非常小的东西。例如：1 微秒（百万分之一秒）：
+=======
+Now let's write something very small. Say, 1 microsecond (one millionth of a second):
+
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```js
 let ms = 0.000001;
 ```
@@ -38,7 +47,7 @@ let ms = 0.000001;
 就像以前一样，使用 `"e"` 可以提供帮助。如果我们想避免明确地写零，我们可以说：
 
 ```js
-let ms = 1e-6; // six zeroes to the left from 1 
+let ms = 1e-6; // six zeroes to the left from 1
 ```
 
 
@@ -152,8 +161,13 @@ alert( num.toString(2) );   // 11111111
     alert( Math.floor(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23
     ```
 
+<<<<<<< HEAD
 2. 函数 [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) 将点数后的数字四舍五入到 `n` 个数字并返回结果的字符串表示。
         
+=======
+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.
+
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
     ```js run
     let num = 12.34;
     alert( num.toFixed(1) ); // "12.3"
@@ -170,19 +184,23 @@ alert( num.toString(2) );   // 11111111
 
     ```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
     ```
 
     我们可以使用一元加号或 `Number()` 调用将其转换为数字：`+ num.toFixed(5)`。
 
 ## 不精确计算
 
+<<<<<<< HEAD
 在 js 内部，一个数字以 64 位格式 [IEEE-754](http://en.wikipedia.org/wiki/IEEE_754-1985) 表示，所以正好有 64 位可以存储一个数字：其中 52 个被使用存储这些数字，其中 11 个存储小数点的位置（它们对于整数为零），1 位用于符号。
+=======
+Internally, a number is represented in 64-bit format [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754-2008_revision), so there are exactly 64 bits to store a number: 52 of them are used to store the digits, 11 of them store the position of the decimal point (they are zero for integer numbers), and 1 bit is for the sign.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如果一个数字太大，它会溢出 64 位存储，可能会输出无穷大：
 
 ```js run
-alert( 1e500 ); // Infinity 
+alert( 1e500 ); // Infinity
 ```
 
 可能不那么明显，但经常会发生精度的损失。
@@ -193,7 +211,11 @@ alert( 1e500 ); // Infinity
 alert( 0.1 + 0.2 == 0.3 ); // *!*false*/!*
 ```
 
+<<<<<<< HEAD
 没错，如果我们检查 `0.1` 和 `0.2` 的总和是否为 `0.3`，们会得到 `false`。
+=======
+That's right, if we check whether the sum of `0.1` and `0.2` is `0.3`, we get `false`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 奇怪！那么如果不是 `0.3`，那么又是什么呢？
 
@@ -201,13 +223,23 @@ alert( 0.1 + 0.2 == 0.3 ); // *!*false*/!*
 alert( 0.1 + 0.2 ); // 0.30000000000000004
 ```
 
+<<<<<<< HEAD
 哎哟!这里的错误有更大的误差。想象一下，你正在制作一个电子购物网站，访问者将 `0.10 美元` 和 `0.20 美元` 商品放入他的图表中。订单总额将是 `$ 0.30000000000000004`。这会让任何人感到惊讶。
+=======
+Ouch! There are more consequences than an incorrect comparison here. Imagine you're making an e-shopping site and the visitor puts `$0.10` and `$0.20` goods into their chart. The order total will be `$0.30000000000000004`. That would surprise anyone.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 但为什么会发生这样的事呢？
 
+<<<<<<< HEAD
 一个数字以二进制形式存储在内存中，一个 1 和 0 的序列。但是像十进制数字系统看起来很简单的 `0.1`，`0.2` 这样的分数实际上是二进制形式的无限分数。
 
 换句话说，什么是 `0.1`？`0.1` 就是把 1 除以 10 `1/10`，即十分之一。在十进制数字系统中，这些数字很容易表示。将它比作三分之一：`1/3`。它变成了无尽的分数 `0.33333(3)`。
+=======
+A number is stored in memory in its binary form, a sequence of bits - ones and zeroes. But fractions like `0.1`, `0.2` that look simple in the decimal numeric system are actually unending fractions in their binary form.
+
+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)`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 所以，按这种用 `10` 划分可以保证在十进制系统中运行良好，但用 `3` 划分不是。出于同样的原因，在二进制数字系统中，`2` 的幂的分割保证工作，但 `1/10` 变成一个无限的二进制分数。
 
@@ -227,40 +259,62 @@ alert( 0.1.toFixed(20) ); // 0.10000000000000000555
 ```smart header="不仅仅是 JavaScript"
 许多其他编程语言也存在同样的问题。
 
+<<<<<<< HEAD
 PHP, Java, C, Perl, Ruby 给出完全相同的结果，因为它们基于相同的数字格式。
 ```
 
 我们能解决这个问题吗？当然，有很多方法：
 
 1. 我们可以在特定函数的帮助下对结果进行四舍五入 [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):
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
+```js run
+let sum = 0.1 + 0.2;
+alert( sum.toFixed(2) ); // 0.30
+```
+
+<<<<<<< HEAD
     请注意 `toFixed` 总是返回一个字符串。它确保它在小数点后有 2 位数字。如果我们有电子购物并需要显示 `0.30 美元`，这实际上很方便。对于其他情况，我们可以使用一元加号将它强制为一个数字：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
-    ```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. 我们可以暂时将数字转换为数学整数，然后将其恢复。它是这样工作的：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
-    ```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
     这是有效的，因为当我们做 `0.1 * 10 = 1` 和 `0.2 * 10 = 2` 时，那么这两个数字就变成了整数，并且没有精度损失。
 
 3. 如果我们在与一家商店打交道，那么最激进的解决方案就是将所有价格存储在美分中，并且根本不使用分数。但是，如果我们应用 30％ 的折扣呢？在实践中，完全回避分数是很难实现的，所以上述解决方案有助于避免这种缺陷。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ````smart header="有趣的事情"
 尝试运行这个：
 
 ```js run
-// Hello! I'm a self-increasing number! 
+// Hello! I'm a self-increasing number!
 alert( 9999999999999999 ); // shows 10000000000000000
 ```
 
@@ -272,7 +326,11 @@ JavaScript 在这种事件中不会触发错误。它尽最大努力使数字符
 ```samrt header="两个零"
 数字内部表示的另一个有趣结果是存在两个零：`0` 和 `-0`。
 
+<<<<<<< HEAD
 这是因为一个符号由一个位表示，所以每个数字可以是正数或负数，包括零。 
+=======
+That's because a sign is represented by a single bit, so every number can be positive or negative, including a zero.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在大多数情况下，这种区别并不明显，因为操作员可以将它们视为相同。
 ```
@@ -283,8 +341,13 @@ JavaScript 在这种事件中不会触发错误。它尽最大努力使数字符
 
 还记得这两个特殊的数值吗？
 
+<<<<<<< HEAD
 - `Infinite`（和 `-Infinite`）是一个特殊的数值，比任何数值都大（小）。
 - `NaN` 代表一个错误。
+=======
+- `Infinity` (and `-Infinity`) is a special numeric value that is greater (less) than anything.
+- `NaN` represents an error.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 它们属于 `数字` 类型，但不是 `普通` 数字，因此有特殊函数可以检查它们：
 
@@ -326,10 +389,17 @@ alert( isFinite(num) );
 
 有一种特殊的内置方法 [Object.is](mdn:js/Object/is)，它可以比较 `===` 等值，但对于两种边缘情况更可靠： 
 
+<<<<<<< HEAD
 1. 它适用于 `NaN`： `Object.is（NaN，NaN）=== true`，这是件好事。
 2. 值 `0` 和 `-0` 是不同的：`Object.is（0，-0）=== false`，它不是很重要，但这些值在技术上是不同的。
 
 在所有其他情况下，`Object.is(a，b)` 与 `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`, technically that's true, because internally the number has a sign bit that may be different even if all other bits are zeroes.
+
+In all other cases, `Object.is(a, b)` is the same as `a === b`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这种比较方式经常用于 JavaScript 规范。当内部算法需要比较两个值完全相同时，它使用 Object.is（内部称为 [SameValue](https://tc39.github.io/ecma262/#sec-samevalue)）。
 ```
@@ -349,7 +419,11 @@ alert( +"100px" ); // NaN
 
 这就是 `parseInt` 和 `parseFloat` 的作用。
 
+<<<<<<< HEAD
 他们从字符串中“读出”一个数字，直到他们可以。如果发生错误，则返回收集的数字。函数 `parseInt` 返回一个整数，而 `parseFloat` 将返回一个浮点数：
+=======
+They "read" a number from a string until they can't. In case of an error, the gathered number is returned. The function `parseInt` returns an integer, whilst `parseFloat` will return a floating-point number:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 alert( parseInt('100px') ); // 100
@@ -417,9 +491,13 @@ JavaScript 有一个内置的 [Math](https://developer.mozilla.org/en/docs/Web/J
 
 对于不同的进制：
 
+<<<<<<< HEAD
 - 可以在十六进制（`0x`），八进制（`0o`）和二进制（`0b`）系统中直接写入数字。
 - `parseInt(str，base)` 解析来自任何数字系统的整数，其基数为：`2≤base≤36`。
 - `num.toString(base)` 将数字转换为数字系统中具有给定 `base` 的字符串。
+=======
+- 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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 将 `12pt` 和 `100px` 等值转换为数字：
 
@@ -427,9 +505,13 @@ JavaScript 有一个内置的 [Math](https://developer.mozilla.org/en/docs/Web/J
 
 分数：
 
+<<<<<<< HEAD
 - 使用 `Math.floor`，`Math.ceil`，`Math.trunc`，`Math.round` 或 `num.toFixed(precision)` 循环。
 - 请记住，使用分数时会损失精度。
 
 更多的数学函数：
 
 - 需要时请参阅 [Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math) 对象,虽然这个文档非常小,但是它可以满足基础的要求。
+=======
+- 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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/1-js/05-data-types/03-string/1-ucfirst/solution.md b/1-js/05-data-types/03-string/1-ucfirst/solution.md
index 3beccff9ff..e709a7d0de 100644
--- a/1-js/05-data-types/03-string/1-ucfirst/solution.md
+++ b/1-js/05-data-types/03-string/1-ucfirst/solution.md
@@ -15,7 +15,7 @@ let newStr = str[0].toUpperCase() + str.slice(1);
 
 这是第二种变体：
 
-```js run
+```js run demo
 function ucFirst(str) {
   if (!str) return str;
 
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 a65b37dad6..8522336862 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,6 +1,10 @@
+<<<<<<< HEAD
 为了使搜索不区分大小写，我们将字符串改为小写，然后搜索：
+=======
+To make the search case-insensitive, let's bring the string to lower case and then search:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
-```js run
+```js run demo
 function checkSpam(str) {
   let lowerStr = str.toLowerCase();
 
diff --git a/1-js/05-data-types/03-string/2-check-spam/task.md b/1-js/05-data-types/03-string/2-check-spam/task.md
index c330b26879..bfaae8fab9 100644
--- a/1-js/05-data-types/03-string/2-check-spam/task.md
+++ b/1-js/05-data-types/03-string/2-check-spam/task.md
@@ -4,7 +4,11 @@ importance: 5
 
 # 检查 spam
 
+<<<<<<< HEAD
 写一个函数 `checkSpam(str)`，如果 `str` 包含 `viagra` 或 `XXX` 就返回 `true`，否则返回 `false`。
+=======
+Write a function `checkSpam(str)` that returns `true` if `str` contains 'viagra' or 'XXX', otherwise false.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 函数必须不区分大小写：
 
diff --git a/1-js/05-data-types/03-string/3-truncate/_js.view/test.js b/1-js/05-data-types/03-string/3-truncate/_js.view/test.js
index c252f16bee..9914923315 100644
--- a/1-js/05-data-types/03-string/3-truncate/_js.view/test.js
+++ b/1-js/05-data-types/03-string/3-truncate/_js.view/test.js
@@ -1,5 +1,5 @@
 describe("truncate", function() {
-  it("truncate the long string to the given lenth (including the ellipsis)", function() {
+  it("truncate the long string to the given length (including the ellipsis)", function() {
     assert.equal(
       truncate("What I'd like to tell on this topic is:", 20),
       "What I'd like to te…"
@@ -13,4 +13,4 @@ describe("truncate", function() {
     );
   });
 
-});
\ No newline at end of file
+});
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 9e4860bc51..503e704342 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 @@
 
 注意省略号实际上有一个 unicode 字符，而不仅仅是三个点。
 
-```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 8b13789179..e69de29bb2 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 1f104edb6b..fef23b07fc 100644
--- a/1-js/05-data-types/03-string/article.md
+++ b/1-js/05-data-types/03-string/article.md
@@ -132,7 +132,11 @@ alert( `My\n`.length ); // 3
 ```warn header="`length` is a property"
 掌握其他语言的人，有时会错误地调用 `str.length()` 而不是 `str.length`。这是行不通的。
 
+<<<<<<< HEAD
 请注意 `str.length` 是一个数字属性，而不是函数。之后不需要添加括号。
+=======
+Please note that `str.length` is a numeric property, not a function. There is no need to add parenthesis after it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ## 访问字符。
@@ -275,8 +279,13 @@ while ((pos = str.indexOf(target, pos + 1)) != -1) {
 */!*
 ```
 
+<<<<<<< HEAD
 ```smart header="`str.lastIndexOf(subStr, pos)`"
 还有一个类似的方法 [str.lastIndexOf(subStr, pos)](mdn:js/String/lastIndexOf)，他从字符串的末尾开始搜索。
+=======
+```smart header="`str.lastIndexOf(substr, position)`"
+There is also a similar method [str.lastIndexOf(substr, position)](mdn:js/String/lastIndexOf) that searches from the end of a string to its beginning.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 它会以相反的顺序列出事件。
 ```
@@ -451,7 +460,11 @@ JavaScript 中有三种获取字符串的方法：`substring`、`substr` 和 `sl
 ```smart header="Which one to choose?"
 他们可以完成这项工作，形式上，`substr` 有一个小缺点：它不是在 JavaScript 核心规范中描述的，而是在附录 B 中，它涵盖了主要由于历史原因而存在的浏览器特性。因此，非浏览器环境可能无法支持它。但实际上它在任何地方都有效。
 
+<<<<<<< HEAD
 作者发现自己几乎一直在使用 `slice`。
+=======
+The author finds themself using `slice` almost all the time.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ## 比较字符串
@@ -551,7 +564,11 @@ alert( 'Österreich'.localeCompare('Zealand') ); // -1
 ## 内部，Unicode
 
 ```warn header="Advanced knowledge"
+<<<<<<< HEAD
 这部分会深入字符串内部。如果你计划处理表情符号、罕见的象形文字字符或其他罕见符号，这些知识会对你有用。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如果你不打算支持它们，你可以跳过这一部分。
 ```
diff --git a/1-js/05-data-types/04-array/10-maximal-subarray/_js.view/test.js b/1-js/05-data-types/04-array/10-maximal-subarray/_js.view/test.js
index 143ad53451..b44e76fe7e 100644
--- a/1-js/05-data-types/04-array/10-maximal-subarray/_js.view/test.js
+++ b/1-js/05-data-types/04-array/10-maximal-subarray/_js.view/test.js
@@ -30,4 +30,8 @@ describe("getMaxSubSum", function() {
   it("maximal subsum of [-1, -2] equals 0", function() {
     assert.equal(getMaxSubSum([-1, -2]), 0);
   });
-});
\ No newline at end of file
+
+  it("maximal subsum of [2, -8, 5, -1, 2, -3, 2] equals 6", function() {
+    assert.equal(getMaxSubSum([2, -8, 5, -1, 2, -3, 2]), 6);
+  });
+});
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 60cc94afd0..c04fa31a45 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
 # 慢的解决方案
+=======
+# Slow solution
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 我们可以计算所有可能的子集的和。
 
@@ -29,8 +33,13 @@
 -9
 -9 + 11
 
+<<<<<<< HEAD
 // 从 -11 开始：
 -11
+=======
+// Starting from 11
+11
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 这样写出来的代码实际上是一个嵌套循环：外部循环遍历数组所有元素，然后内部循环计算从当前元素之后的所有子数组集的和。
@@ -59,7 +68,11 @@ alert( getMaxSubSum([100, -9, 2, -3, 5]) ); // 100
 
 该方案的时间复杂度是 [O(n<sup>2</sup>)](https://en.wikipedia.org/wiki/Big_O_notation)。也就是说，如果我们把数组大小增加 2 倍，那么算法的运行时间将会延长4倍。
 
+<<<<<<< HEAD
 对于大型数组（1000，10000 或者更多项）这种算法会导致严重的时间消耗。
+=======
+For big arrays (1000, 10000 or more items) such algorithms can lead to a serious sluggishness.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 # 快的解决方案
 
@@ -67,7 +80,7 @@ alert( getMaxSubSum([100, -9, 2, -3, 5]) ); // 100
 
 如果文字描述不太好理解，就直接看下面的代码吧，真的很短：
 
-```js run
+```js run demo
 function getMaxSubSum(arr) {
   let maxSum = 0;
   let partialSum = 0;
diff --git a/1-js/05-data-types/04-array/10-maximal-subarray/task.md b/1-js/05-data-types/04-array/10-maximal-subarray/task.md
index 0f05a0843e..d718723519 100644
--- a/1-js/05-data-types/04-array/10-maximal-subarray/task.md
+++ b/1-js/05-data-types/04-array/10-maximal-subarray/task.md
@@ -8,7 +8,11 @@ importance: 2
 
 任务是：找出连续的 `arr` 的子数组，其里面所有项的和最大。
 
+<<<<<<< HEAD
 写出函数 `getMaxSubSum(arr)`，用其找出并返回最大和。
+=======
+Write the function `getMaxSubSum(arr)` that will return that sum.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如：
 
@@ -27,4 +31,8 @@ getMaxSubSum([*!*1, 2, 3*/!*]) = 6 (所有项的和)
 getMaxSubSum([-1, -2, -3]) = 0
 ```
 
+<<<<<<< HEAD
 请尝试想出一个快速的解决方案：复杂度可以是 [O(n<sup>2</sup>)](https://en.wikipedia.org/wiki/Big_O_notation)，有能力达到 O(n) 则更好。
+=======
+Please try to think of a fast solution: [O(n<sup>2</sup>)](https://en.wikipedia.org/wiki/Big_O_notation) or even O(n) if you can.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 eec9055e7c..f032b55f0c 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 023642fa7c..4d6867b14b 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 301fd8f66b..c65ef94467 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 5f2cef5dd0..5798a64760 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 1bd68b3154..ba95f2651e 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 3737e8248f..a400d0c1d8 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 e45624b502..11a3e67c91 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 3336a3b3bb..0932ac5b42 100644
--- a/1-js/05-data-types/04-array/article.md
+++ b/1-js/05-data-types/04-array/article.md
@@ -1,12 +1,24 @@
+<<<<<<< HEAD
 # 数组
 
 对象允许存储键值化的集合，这很好。
  
 但很多时候我们需要的是**有序集合**，里面的元素都是按顺序排列的。例如，我们可能需要存储一些列表，比如用户、商品以及 HTML 元素等。
+=======
+# Arrays
+
+Objects allow you to store keyed collections of values. That's fine.
+
+But quite often we find that we need an *ordered collection*, where we have a 1st, a 2nd, a 3rd element and so on. For example, we need that to store a list of something: users, goods, HTML elements etc.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这里使用对象就不是很方便了，因为对象不提供能够管理元素顺序的方法。我们不能在已有的元素“之间”插入一个新的属性。这种场景下对象就不太适用了。
 
+<<<<<<< HEAD
 这时一个特殊的数据结构数组（`Array`）就派上用场了，它能存储有序的集合。
+=======
+There exists a special data structure named `Array`, to store ordered collections.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 声明
 
@@ -79,12 +91,18 @@ arr[3](); // hello
 ```
 
 
+<<<<<<< HEAD
 ````smart header="以逗号结尾"
 数组和对象一样，都可以在末尾冗余一个逗号：
 ```js 
+=======
+````smart header="Trailing comma"
+An array, just like an object, may end with a comma:
+```js
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 let fruits = [
-  "Apple", 
-  "Orange", 
+  "Apple",
+  "Orange",
   "Plum"*!*,*/!*
 ];
 ```
@@ -95,7 +113,11 @@ let fruits = [
 
 ## pop/push, shift/unshift 方法
 
+<<<<<<< HEAD
 [队列](https://en.wikipedia.org/wiki/Queue_(abstract_data_type))是最常见的使用数组的方法之一. 在计算机科学中，这意味着一个有序的元素的集合支持两个操作：
+=======
+A [queue](https://en.wikipedia.org/wiki/Queue_(abstract_data_type)) is one of the most common uses of an array. In computer science, this means an ordered collection of elements which supports two operations:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - `push` 在末端添加一个元素.
 - `shift` 取出队列最前端的一个元素，整个队列往前移，这样原先排第二的元素现在排在了第一。
@@ -104,9 +126,15 @@ let fruits = [
 
 这两种操作数组都支持.
 
+<<<<<<< HEAD
 队列的应用在实践中经常会碰到，例如需要在屏幕上显示消息队列。
 
 数组还有另一个用例，就是数据结构[栈](https://en.wikipedia.org/wiki/Stack_(abstract_data_type))。
+=======
+In practice we need it very often. For example, a queue of messages that need to be shown on-screen.
+
+There's another use case for arrays -- the data structure named [stack](https://en.wikipedia.org/wiki/Stack_(abstract_data_type)).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 它支持两种操作：
 
@@ -121,7 +149,11 @@ let fruits = [
 
 对于栈来说，最后放进去的是最先接收的，也叫做 LIFO（后进先出）法则。而与队列相对应的叫做 FIFO（先进先出）。
 
+<<<<<<< HEAD
 JavaScript 中的数组既可以用作队列，也可以用作栈。它们允许从前端/末端来添加/删除元素。
+=======
+Arrays in JavaScript can work both as a queue and as a stack. They allow you to add/remove elements both to/from the beginning or the end.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这在计算机科学中叫做[双端队列](https://en.wikipedia.org/wiki/Double-ended_queue)。
 
@@ -189,11 +221,19 @@ alert( fruits );
 
 ## 内部
 
+<<<<<<< HEAD
 数组是一种特殊的对象。使用方括号来访问属性 `arr[0]` 实际上是来自于对象的语法。这个数字被用作键值。
+=======
+An array is a special kind of object. The square brackets used to access a property `arr[0]` actually come from the object syntax. That's essentially the same as `obj[key]`, where `arr` is the object, while numbers are used as keys.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 他们扩展了对象，提供了特殊的方法来处理有序的数据集合，还添加了 `length` 属性。但是核心还是一个对象。
 
+<<<<<<< HEAD
 记住，在 JavaScript 中只有 7 种基本类型。数组是一个对象因此其行为也像一个对象。
+=======
+Remember, there are only 7 basic types in JavaScript. Array is an object and thus behaves like an object.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如，它是通过引用来复制的：
 
@@ -203,6 +243,11 @@ let fruits = ["Banana"]
 let arr = fruits; // 通过引用复制 (两个变量引用的是相同的数组)
 
 alert( arr === fruits ); // true
+<<<<<<< HEAD
+=======
+
+arr.push("Pear"); // modify the array by reference
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 arr.push("Pear"); // 通过引用修改数组
 
@@ -229,9 +274,15 @@ fruits.age = 25; // 用任意的名字创建属性
 
 数组误用的几种方式:
 
+<<<<<<< HEAD
 - 添加一个非数字的属性比如 `arr.test = 5`。
 - 制造空洞，比如：添加 `arr[0]` 后添加 `arr[1000]` (它们中间什么都没有)。
 - 以倒序填充数组, 比如 `arr[1000]`，`arr[999]` 等等。
+=======
+- Add a non-numeric property like `arr.test = 5`.
+- Make holes, like: add `arr[0]` and then `arr[1000]` (and nothing between them).
+- Fill the array in the reverse order, like `arr[1000]`, `arr[999]` and so on.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 请将数组视为作用于**有序数据**的特殊结构，它们为此提供了特殊的方法。数组在 JavaScript 引擎内部是经过特殊调整的，使得更好的作用于连续的有序数据，所以请以这种方式使用数组。如果你需要任意键值，那很有可能实际上你需要的是常规对象 `{}`。
 
@@ -296,7 +347,7 @@ let fruits = ["Apple", "Orange", "Plum"];
 
 // 迭代数组元素
 for (let fruit of fruits) {
-  alert( fruit ); 
+  alert( fruit );
 }
 ```
 
@@ -320,7 +371,11 @@ for (let key in arr) {
 
     在浏览器和其它环境中有一种“类数组”的对象，它们**看似是数组**，也就是说，它们有 `length` 和索引属性，但是也可能有其它的非数字的属性和方法，这通常是我们不需要的。`for..in` 循环会把它们都列出来。所以如果我们需要处理类数组对象，这些“额外”的属性就会存在问题。
 
+<<<<<<< HEAD
 2. `for..in` 循环适用于普通对象，不适用于数组，而且会慢 10-100 倍。当然即使是这样也依然非常快。只有在遇到瓶颈或者一些不相关的场景增速可能会有问题。但是我们仍然应该了解这其中的不同。
+=======
+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. But still we should be aware of the difference.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 通常来说，我们不应该用 `for..in` 来处理数组。
 
@@ -338,7 +393,11 @@ fruits[123] = "Apple";
 alert( fruits.length ); // 124
 ```
 
+<<<<<<< HEAD
 要知道的是我们通常不会这样使用数组。
+=======
+Note that we usually don't use arrays like that.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `length` 属性的另一个有意思的点是它是可写的。
 
@@ -369,7 +428,11 @@ let arr = *!*new Array*/!*("Apple", "Pear", "etc");
 
 如果调用 `new Array` 使用的是一个单独的数字作为参数，那么就会创建一个**指定了长度，却没有任何项**的数组。
 
+<<<<<<< HEAD
 让我们看看如何搬起石头砸自己的脚:
+=======
+Let's see how one can shoot themself in the foot:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let arr = new Array(2); // 会创建一个数组 [2] 吗？
@@ -385,7 +448,11 @@ alert( arr.length ); // length 2
 
 ## 多维数组
 
+<<<<<<< HEAD
 数组里的项也可以是数组。我们可以以多维数组的方式存储矩阵：
+=======
+Arrays can have items that are also arrays. We can use it for multidimensional arrays, for example to store matrices:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let matrix = [
@@ -431,7 +498,11 @@ alert( "1,2" + 1 ); // "1,21"
 
 ## 总结
 
+<<<<<<< HEAD
 数组是一种特殊的对象，适用于存储和管理有序的数据项。
+=======
+Array is a special kind of object, suited to storing and managing ordered data items.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - 声明:
 
@@ -443,7 +514,14 @@ alert( "1,2" + 1 ); // "1,21"
     let arr = new Array(item1, item2...);
     ```
 
+<<<<<<< HEAD
     调用 `new Array(number)` 会创建一个指定长度的数组，且不含有任何项。
+=======
+    The call to `new Array(number)` creates an array with the given length, but without elements.
+
+- The `length` property is the array length or, to be precise, its last numeric index plus one. It is auto-adjusted by array methods.
+- If we shorten `length` manually, the array is truncated.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - `length` 属性是数组的长度，准确地说，是它的最后一个数字索引值加一。它由数组方法自动调整。
 - 如果我们手动缩短 `length`，那么数组就会被截断。
@@ -455,9 +533,13 @@ alert( "1,2" + 1 ); // "1,21"
 - `shift()` 从前端移除并返回该元素。
 - `unshift(...items)` 从前端添加项 `items`。
 
+<<<<<<< HEAD
 遍历数组的元素：
   - `for (let i=0; i<arr.length; i++)` — 运行的最快, 可兼容旧版本浏览器。
   - `for (let item of arr)` — 现代语法，只能访问 items。
   - `for (let i in arr)` — 永远不会使用。
 
 在下一章节我们会回顾数组然后学习更多添加、移动、提取元素和数组排序的方法。 <info:array-methods>。
+=======
+We will return to arrays and study more methods to add, remove, extract elements and sort arrays in the chapter <info:array-methods>.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/1-js/05-data-types/04-array/queue.png b/1-js/05-data-types/04-array/queue.png
index 5e1fb640ce..39af3beda4 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 6acfc83d12..75045a51dc 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 d1c9cb9afd..7d2599355b 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 b3835fa442..16c6225186 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 024d6d6c2b..490f570ada 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/10-average-age/task.md b/1-js/05-data-types/05-array-methods/10-average-age/task.md
index 5ef6491bb1..089db5828a 100644
--- a/1-js/05-data-types/05-array-methods/10-average-age/task.md
+++ b/1-js/05-data-types/05-array-methods/10-average-age/task.md
@@ -4,7 +4,11 @@ importance: 4
 
 # 获取平均
 
+<<<<<<< HEAD
 编写 `getAverageAge(users)` 函数，该函数获取一个具有 age 属性的对象数组，并获取平均值。
+=======
+Write the function `getAverageAge(users)` that gets an array of objects with property `age` and returns the average age.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 平均的公式是 `(age1 + age2 + ... + ageN) / N`。
 
@@ -19,4 +23,3 @@ let arr = [ john, pete, mary ];
 
 alert( getAverageAge(arr) ); // (25 + 30 + 29) / 3 = 28
 ```
-
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 65995830dc..9f94804997 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 @@
 - 对于每个元素，我们将检查结果数组是否已经有该元素。
 - 如果有，则忽略，否则添加结果。
 
-```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 e69de29bb2..73993a07a0 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 61cda126b6..488db3755b 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 e69de29bb2..36e3130ff0 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/04-object-basics/06-constructor-new/4-calculator-extendable/_js.view/solution.js b/1-js/05-data-types/05-array-methods/6-calculator-extendable/_js.view/solution.js
similarity index 100%
rename from 1-js/04-object-basics/06-constructor-new/4-calculator-extendable/_js.view/solution.js
rename to 1-js/05-data-types/05-array-methods/6-calculator-extendable/_js.view/solution.js
diff --git a/1-js/04-object-basics/06-constructor-new/4-calculator-extendable/_js.view/test.js b/1-js/05-data-types/05-array-methods/6-calculator-extendable/_js.view/test.js
similarity index 100%
rename from 1-js/04-object-basics/06-constructor-new/4-calculator-extendable/_js.view/test.js
rename to 1-js/05-data-types/05-array-methods/6-calculator-extendable/_js.view/test.js
diff --git a/1-js/04-object-basics/06-constructor-new/4-calculator-extendable/solution.md b/1-js/05-data-types/05-array-methods/6-calculator-extendable/solution.md
similarity index 100%
rename from 1-js/04-object-basics/06-constructor-new/4-calculator-extendable/solution.md
rename to 1-js/05-data-types/05-array-methods/6-calculator-extendable/solution.md
diff --git a/1-js/04-object-basics/06-constructor-new/4-calculator-extendable/task.md b/1-js/05-data-types/05-array-methods/6-calculator-extendable/task.md
similarity index 72%
rename from 1-js/04-object-basics/06-constructor-new/4-calculator-extendable/task.md
rename to 1-js/05-data-types/05-array-methods/6-calculator-extendable/task.md
index 31d72ecb11..99371ddaa2 100644
--- a/1-js/04-object-basics/06-constructor-new/4-calculator-extendable/task.md
+++ b/1-js/05-data-types/05-array-methods/6-calculator-extendable/task.md
@@ -17,7 +17,11 @@ importance: 5
 
     alert( calc.calculate("3 + 7") ); // 10
     ```
+<<<<<<< HEAD:1-js/04-object-basics/06-constructor-new/4-calculator-extendable/task.md
 2. 然后添加 calculate 新操作的方法 `addOperator(name, func)`。它需要运算符 `name` 和实现它的双参数函数 `func(a,b)`。
+=======
+2. Then add the method `addMethod(name, func)` that teaches the calculator a new operation. It takes the operator `name` and the two-argument function `func(a,b)` that implements it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/05-data-types/05-array-methods/6-calculator-extendable/task.md
 
     例如，我们添加乘法`*`，除法`/`和求幂`**`：
 
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 f19ac14aa8..74d8302738 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,22 @@
 ```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);
 
+<<<<<<< HEAD
 // 现在排序是：[john, mary, pete]
+=======
+// now sorted is: [john, mary, pete]
+alert(arr[0].name); // John
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 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 7f4b584b47..4012615d4c 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
 # 排序对象
 
 编写函数 `sortByName(users)` 获得对象数组 property的属性 `name` 并对它进行排序。
+=======
+# Sort users by age
+
+Write the function `sortByAge(users)` that gets an array of objects with the `age` property and sorts them by `age`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如：
 
@@ -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 d9f3963eef..ee5db9fcb3 100644
--- a/1-js/05-data-types/05-array-methods/article.md
+++ b/1-js/05-data-types/05-array-methods/article.md
@@ -36,7 +36,11 @@ alert( arr.length ); // 3
 
 所以应该使用特殊的方法。
 
+<<<<<<< HEAD
 [arr.splice(str)](mdn:js/Array/splice) 方法可以说是数组界的瑞士军刀。它可以做所有事情：添加，删除和插入元素。
+=======
+The [arr.splice(str)](mdn:js/Array/splice) method is a swiss army knife for arrays. It can do everything: insert, remove and replace elements.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 语法是：
 
@@ -122,7 +126,11 @@ alert( arr ); // 1,2,3,4,5
 arr.slice(start, end)
 ```
 
+<<<<<<< HEAD
 它从所有元素的开始索引 `"start"` 复制到 `"end"` (不包括 `"end"`) 返回一个新的数组。`start` 和 `end` 都可以是负数，在这种情况下，从末尾计算索引。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 它和字符串的 `str.slice` 有点像，就是把子字符串替换成子数组。
 
@@ -201,7 +209,40 @@ let arrayLike = {
 alert( arr.concat(arrayLike) ); // 1,2,something,else
 ```
 
+<<<<<<< HEAD
 ## 查询数组
+=======
+## 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
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这些是在数组中查询某些内容的方法。
 
@@ -209,9 +250,15 @@ alert( arr.concat(arrayLike) ); // 1,2,something,else
 
 [arr.indexOf](mdn:js/Array/indexOf)、[arr.lastIndexOf](mdn:js/Array/lastIndexOf) 和 [arr.includes](mdn:js/Array/includes) 方法与字符串操作具有相同的语法，只不过这里是对数组元素而不是字符进行操作：
 
+<<<<<<< HEAD
 - `arr.indexOf(item, from)` 从索引 `from` 查询 `item`，如果找到返回索引，否则返回 `-1`。
 - `arr.lastIndexOf(item, from)` — 和上面相同，只是从尾部开始查询。
 - `arr.includes(item, from)` — 从索引 `from` 查询 `item`，如果找到则返回 `true`。
+=======
+- `arr.indexOf(item, from)` looks for `item` starting from index `from`, and returns the index where it was found, otherwise `-1`.
+- `arr.lastIndexOf(item, from)` -- same, but looks for from right to left.
+- `arr.includes(item, from)` -- looks for `item` starting from index `from`, returns `true` if found.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如：
 
@@ -246,7 +293,12 @@ alert( arr.includes(NaN) );// true (correct)
 语法：
 ```js
 let result = arr.find(function(item, index, array) {
+<<<<<<< HEAD
   // 如果查询到返回 true
+=======
+  // if true is returned, item is returned and iteration is stopped
+  // for falsy scenario returns undefined
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 });
 ```
 
@@ -274,9 +326,15 @@ alert(user.name); // John
 
 在现实生活中，对象数组是很常见，所以`find` 方法非常有用。
 
+<<<<<<< HEAD
 注意在这个例子中我们传给了 `find` 一个单参数函数 `item => item.id == 1`。其他参数 `find` 很少使用。
 
 与 [arr.findIndex](mdn:js/Array/findIndex) 方法本质上是相同的，但它返回找到元素的索引而不是元素本身。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ### filter
 
@@ -284,11 +342,20 @@ alert(user.name); // John
 
 如果需要匹配的有很多，我们可以使用 [arr.filter(fn)](mdn:js/Array/filter)。
 
+<<<<<<< HEAD
 语法与 `find` 大致相同，但是它返回的是所有匹配元素组成的数组：
 
 ```js
 let results = arr.filter(function(item, index, array) {
   // 在元素通过过滤器时返回 true
+=======
+The syntax is similar to `find`, but filter continues to iterate for all array elements even if `true` is already returned:
+
+```js
+let results = arr.filter(function(item, index, array) {
+  // if true item is pushed to results and iteration continues
+  // returns empty array for complete falsy scenario
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 });
 ```
 
@@ -329,7 +396,7 @@ let result = arr.map(function(item, index, array) {
 例如，在这里我们将每个元素转换为它的字符串长度：
 
 ```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
 ```
 
@@ -416,8 +483,13 @@ alert(arr);  // *!*1, 2, 15*/!*
 ```
 ````
 
+<<<<<<< HEAD
 ````smart header="箭头函数最好"
 [箭头函数](info:function-expression#arrow-functions)还记得吗？这里使用箭头函数会更加简洁：
+=======
+````smart header="Arrow functions for the best"
+Remember [arrow functions](info:function-expressions-arrows#arrow-functions)? We can use them here for neater sorting:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 arr.sort( (a, b) => a - b );
@@ -477,7 +549,11 @@ alert( str.split('') ); // t,e,s,t
 ```
 ````
 
+<<<<<<< HEAD
 [arr.join(str)](mdn:js/Array/join) 与 `split` 相反。它会在它们之间创建一串由 `str` 粘合的 `arr` 项。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如：
 
@@ -491,7 +567,11 @@ alert( str ); // Bilbo;Gandalf;Nazgul
 
 ### reduce/reduceRight
 
+<<<<<<< HEAD
 当我们需要遍历一个数组时 — 我们可以使用 `forEach`。
+=======
+When we need to iterate over an array -- we can use `forEach`, `for` or `for..of`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 当我们需要迭代并返回每个元素的数据时 — 我们可以使用 `map`。
 
@@ -500,16 +580,22 @@ alert( str ); // Bilbo;Gandalf;Nazgul
 语法是：
 
 ```js
-let value = arr.reduce(function(previousValue, item, index, arr) {
+let value = arr.reduce(function(previousValue, item, index, array) {
   // ...
 }, initial);
 ```
 
 该函数应用于元素。从第二个参数开始你可能就会觉得很眼熟了：
 
+<<<<<<< HEAD
 - `item` — 当前的数组元素。
 - `index` — 当前索引。
 - `arr` — 数组本身。
+=======
+- `item` -- is the current array item.
+- `index` -- is its position.
+- `array` -- is the array.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 目前为止，这很像 `forEach/map`。但还有一个参数不同就是：
 
@@ -539,7 +625,11 @@ alert(result); // 15
 
 ![](reduce.png)
 
+<<<<<<< HEAD
 或者以表格的形式出现，每行代表的是下一个数组元素的函数调用：
+=======
+Or in the form of a table, where each row represents a function call on the next array element:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 |   |`sum`|`current`|`result`|
 |---|-----|---------|---------|
@@ -585,6 +675,7 @@ arr.reduce((sum, current) => sum + current);
 [arr.reduceRight](mdn:js/Array/reduceRight) 也一样，但是遍历是从右到左。
 
 
+<<<<<<< HEAD
 ## 迭代：forEach
 
 [arr.forEach](mdn:js/Array/forEach) 方法允许为数组的每个元素运行一个函数。
@@ -613,6 +704,8 @@ arr.forEach(function(item, index, array) {
 
 该函数的结果（如果它返回的话）被抛弃并被忽略。
 
+=======
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ## Array.isArray
 
 数组基于对象。不构成单独的语言类型。
@@ -689,11 +782,22 @@ alert(youngerUsers.length); // 2
   - `slice(start, end)` — 它从所有元素的开始索引 `"start"` 复制到 `"end"` (不包括 `"end"`) 返回一个新的数组。
   - `concat(...items)` — 返回一个新数组：复制当前数组的所有成员并向其中添加 `items`。如果有任何` items` 是一个数组，那么就取其元素。
 
+<<<<<<< HEAD
 - 查询元素：
   - `indexOf/lastIndexOf(item, pos)` —  从 `pos` 找到 `item`，则返回索引否则返回 `-1`。
   - `includes(value)` — 如果数组有 `value`，则返回 `true`，否则返回 `false`。
   - `find/filter(func)` — 通过函数过滤元素，返回 `true` 条件的符合 find 函数的第一个值或符合 filter 函数的全部值。 
   - `findIndex` 和 `find` 类似，但返回索引而不是值。
+=======
+- 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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - 转换数组：
   - `map(func)` — 从每个元素调用 `func` 的结果创建一个新数组。
@@ -702,11 +806,16 @@ alert(youngerUsers.length); // 2
   - `split/join` — 将字符串转换为数组并返回。
   - `reduce(func, initial)` — 通过为每个元素调用 `func` 计算数组上的单个值并在调用之间传递中间结果。
 
+<<<<<<< HEAD
 - 迭代元素：
   - `forEach(func)` — 为每个元素调用 `func`，不返回任何东西。
 
 - 其他：
   - `Array.isArray(arr)` 检查 `arr` 是否是一个数组。
+=======
+- Additionally:
+  - `Array.isArray(arr)` checks `arr` for being an array.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 请注意，`sort`，`reverse` 和 `splice` 方法修改数组本身。
 
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 41476d2aea..7566c4d84c 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 f31647d17b..7c9fd6692b 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/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index ada5f4a6e9..eac7af1310 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -3,9 +3,16 @@
 
 **Iterable** （可迭代对象）是数组的泛化。这个概念是说任何对象都可在 `for..of` 循环中使用。
 
+<<<<<<< HEAD
 数组本身就是可迭代的。但不仅仅是数组。字符串也可以迭代，很多其他内建对象也都可以迭代。
 
 在核心 JavaScript 中，可迭代对象用途广泛。我们将会看到，很多内建的操作和方法都依赖于它。
+=======
+Of course, Arrays are iterable. But there are many other built-in objects, that are iterable as well. For instance, Strings are iterable also. As we'll see, many built-in operators and methods rely on them.
+
+If an object represents a collection (list, set) of something, then `for..of` is a great syntax to loop over it, so let's see how to make it work.
+
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## Symbol.iterator
 
@@ -27,10 +34,17 @@ let range = {
 
 为了让 `range` 对象可迭代（也就让 `for..of` 可以运行）我们需要为对象添加一个名为 `Symbol.iterator` 的方法（一个特殊的内置标记）。
 
+<<<<<<< HEAD
 - 当 `for..of` 循环开始，它将会调用这个方法（如果没找到，就会报错）。
 - 这个方法必须返回一个迭代器 —— 一个有 `next` 方法的对象。
 - 当 `for..of` 循环希望取得下一个数值，它就调用这个对象的 `next()` 方法。
 - `next()` 返回结果的格式必须是 `{done: Boolean, value: any}`，当 `done=true` 时，表示迭代结束，否则 `value` 必须是一个未被迭代的新值。
+=======
+1. When `for..of` starts, it calls that method once (or errors if not found). The method must return an *iterator* -- an object with the method `next`.
+2. Onward, `for..of` works *only with that returned object*.
+3. When `for..of` wants the next value, it calls `next()` on that object.
+4. The result of `next()` must have the form `{done: Boolean, value: any}`, where `done=true`  means that the iteration is finished, otherwise `value` must be the new value.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这是 `range` 的全部实现：
 
@@ -43,7 +57,12 @@ let range = {
 // 1. 使用 for..of 将会首先调用它：
 range[Symbol.iterator] = function() {
 
+<<<<<<< HEAD
   // 2. ...它返回一个迭代器：
+=======
+  // ...it returns the iterator object:
+  // 2. Onward, for..of works only with this iterator, asking it for next values
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
   return {
     current: this.from,
     last: this.to,      
@@ -66,10 +85,17 @@ for (let num of range) {
 }
 ```
 
+<<<<<<< HEAD
 这段代码中有几点需要着重关注：
 
 - `range` 自身没有 `next()` 方法。
 - 相反，是调用 `range[Symbol.iterator]()` 时将会被创建的另一个所谓的“迭代器”对象，将会处理迭代操作。
+=======
+Please note the core feature of iterables: an important separation of concerns:
+
+- The `range` itself does not have the `next()` method.
+- Instead, another object, a so-called "iterator" is created by the call to `range[Symbol.iterator]()`, and it handles the whole iteration.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 所以，迭代器对象和迭代的对象其实是分离的。
 
@@ -101,10 +127,19 @@ for (let num of range) {
 }
 ```
 
+<<<<<<< HEAD
 现在 `range[Symbol.iterator]()` 返回了 `range` 对象自身：它包括了必需的 `next()` 方法并通过 `this.current` 记忆了当前迭代进程。有时候，这样也可以。但缺点是，现在不可能同时在 `range` 上运行两个 `for..of` 循环了：这两个循环将会共享迭代状态，因为仅有一个迭代器 —— 也就是对象自身。
 
 ```smart header="Infinite iterators"
 无穷迭代也是可行的。例如，`range` 设置为 `range.to = Infinity` 则成为无穷迭代。或者我们可以创建一个可迭代对象，它生成一个伪随机数无穷序列。也是可用的。
+=======
+Now `range[Symbol.iterator]()` returns the `range` object itself:  it has the necessary `next()` method and remembers the current iteration progress in `this.current`. Shorter? Yes. And sometimes that's fine too.
+
+The downside is that now it's impossible to have two `for..of` loops running over the object simultaneously: they'll share the iteration state, because there's only one iterator -- the object itself. But two parallel for-ofs is a rare thing, even in async scenarios.
+
+```smart header="Infinite iterators"
+Infinite iterators are also possible. For instance, the `range` becomes infinite for `range.to = Infinity`. Or we can make an iterable object that generates an infinite sequence of pseudorandom numbers. Also can be useful.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `next` 没有什么限制，它可以返回越来越多的值，这也很常见。
 
@@ -120,11 +155,20 @@ for (let num of range) {
 
 ```js run
 for (let char of "test") {
+<<<<<<< HEAD
   alert( char ); // t，然后 e，然后 s，然后 t
 }
 ```
 
 对于 UTF-16 的扩展字符，它也能正常工作！
+=======
+  // triggers 4 times: once for each character
+  alert( char ); // t, then e, then s, then t
+}
+```
+
+And it works correctly with surrogate pairs!
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let str = '𝒳😂';
@@ -139,7 +183,11 @@ for (let char of str) {
 
 但是为了更深层的了解知识概念，我们来看看如何显式的创建迭代器。
 
+<<<<<<< HEAD
 我们将会采用与 `for..of` 一样的方法迭代字符串，但是是直接的调用。这段代码将会获取字符串的迭代器，然后“手动”调用它。
+=======
+We'll iterate over a string in exactlly the same way as `for..of`, but with direct calls. This code creates a string iterator and gets values from it "manually":
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let str = "Hello";
@@ -165,7 +213,13 @@ while (true) {
 - **Iterables** 是应用于 `Symbol.iterator` 方法的对象，像上文所述。
 - **Array-likes** 是有索引和 `length` 属性的对象，所以它们很像数组。
 
+<<<<<<< HEAD
 很自然的，这些属性都可以结合起来。例如，字符串既是可迭代对象（`for..of` 可以迭代字符串）也是类数组对象（它们有数字索引也有 `length` 属性）。
+=======
+When we use JavaScript for practical tasks in browser or other environments, we may meet objects that are iterables or array-likes, or both.
+
+For instance, strings are both iterable (`for..of` works on them) and array-like (they have numeric indexes and `length`).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 但是一个可迭代对象也许不是类数组对象。反之亦然，一个类数组对象可能也不可迭代。
 
@@ -186,11 +240,19 @@ for (let item of arrayLike) {}
 */!*
 ```
 
+<<<<<<< HEAD
 它们有什么共同点？可迭代对象和类数组对象通常都不是数组，他们没有 `push`，`pop` 等等方法。如果我们有一个这样的对象并且想像数组那样操作它，这就有些不方便了。
 
 ## Array.from
 
 有一个全局方法 [Array.from](mdn:js/Array/from) 可以把它们全都结合起来。它以一个可迭代对象或者类数组对象作为参数并返回一个真正的 `Array` 数组。然后我们就可以用该对象调用数组的方法了。
+=======
+Both iterables and array-likes are usually *not arrays*, they don't have `push`, `pop` etc. That's rather inconvenient if we have such an object and want to work with it as with an array. E.g. we would like to work with `range` using array methods. How to achieve that?
+
+## Array.from
+
+There's a universal method [Array.from](mdn:js/Array/from) that takes an iterable or array-like value and makes a "real" `Array` from it. Then we can call array methods on it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如：
 
@@ -222,7 +284,11 @@ alert(arr); // 1,2,3,4,5 （数组的 toString 转化函数生效）
 Array.from(obj[, mapFn, thisArg])
 ```
 
+<<<<<<< HEAD
 第二个参数 `mapFn` 应是一个在元素被添加到数组前，施加于每个元素的方法，`thisArg` 允许设置方法的 `this` 对象。
+=======
+The optional second argument `mapFn` can be a function that will be applied to each element before adding to the array, and `thisArg` allows to set `this` for it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如：
 
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 101ad46b9f..28dc38acef 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 @@ map.set(sorted, word);
 
 这就是答案：
 
-```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 c86540e3d8..a8f8203955 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,11 @@ map.set("name", "John");
 let keys = map.keys();
 
 *!*
+<<<<<<< HEAD
 // 错误：numbers.push 不是一个函数
+=======
+// Error: keys.push is not a function
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 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 00c3a3722a..dc5f9db1d3 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
@@ -47,7 +47,11 @@ alert( map.size ); // 3
 ```js run
 let john = { name: "John" };
 
+<<<<<<< HEAD
 // 存下每个用户的来访次数
+=======
+// for every user, let's store their visits count
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 let visitsCountMap = new Map();
 
 // john 是 map 的键
@@ -159,6 +163,7 @@ for (let entry of recipeMap) { // 和 recipeMap.entries() 一样
 另外，`Map` 有一个内建的 `forEach` 方法，和 `Array` 很像：
 
 ```js
+// runs the function for each (key, value) pair 
 recipeMap.forEach( (value, key, map) => {
   alert(`${key}: ${value}`); // cucumber: 500 等等
 });
@@ -223,7 +228,11 @@ set.forEach((value, valueAgain, set) => {
 
 注意到这里有个有趣得事情。`forEach` 函数用于 `Set` 时有三个参数：value，然后又一个 value，之后是目标对象。确实，相同值的 value 在参数中出现了两次。
 
+<<<<<<< HEAD
 这是为了兼容 `Map`，它在使用 `forEach` 方法时也包括三个参数。
+=======
+That's for compatibility with `Map` where `forEach` has three arguments. Looks a bit strange, for sure. But may help to replace `Map` with `Set` in certain cases with ease, and vice versa.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 适用于 `Map` 的迭代方法 set 也同样支持：
 
@@ -253,9 +262,33 @@ john = null;
 
 通常情况下，当某数据存在于内存中时，对象的属性或者数组的元素或其他的数据结构将被认为是可以获取的并留存于内存。
 
+<<<<<<< HEAD
 在一个正常 `Map` 中，我们将某对象存储为键还是值并不重要。它将会被一直保留在内存中，就算已经没有指向它的引用。
 
 例如：
+=======
+For instance, if we put an object into an array, then while the array is alive, the object will be alive as well, even if there are no other references to it.
+
+Like this:
+
+```js
+let john = { name: "John" };
+
+let array = [ john ];
+
+john = null; // overwrite the reference
+
+*!*
+// john is stored inside the array, so it won't be garbage-collected
+// we can get it as array[0]
+*/!*
+```
+
+Or, if we use an object as the key in a regular `Map`, then while the `Map` exists, that object exists as well. It occupies memory and may not be garbage collected.
+
+For instance:
+
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```js
 let john = { name: "John" };
 
@@ -265,12 +298,19 @@ map.set(john, "...");
 john = null; // 覆盖引用
 
 *!*
+<<<<<<< HEAD
 // john 被保存在 map 中
 // 我们可以通过 map.keys() 得到它
+=======
+// john is stored inside the map,
+// we can get it by using map.keys()
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 */!*
 ```
 
+`WeakMap/WeakSet` are fundamentally different in this aspect. They do not prevent garbage-collection of key objects.
 
+<<<<<<< HEAD
 除了 `WeakMap/WeakSet`。
 
 **`WeakMap/WeakSet` 不会阻止内存移除对象。**
@@ -278,6 +318,11 @@ john = null; // 覆盖引用
 我们从 `WeakMap` 开始。
 
 它和 `Map` 的第一个区别是它的键必须是对象，不能是基础类型的值：
+=======
+Let's explain it starting with `WeakMap`.
+
+The first difference from `Map` is that `WeakMap` keys must be objects, not primitive values:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let weakMap = new WeakMap();
@@ -287,7 +332,12 @@ let obj = {};
 weakMap.set(obj, "ok"); // 运行正常（对象作为键）
 
 *!*
+<<<<<<< HEAD
 weakMap.set("test", "Whoops"); // 错误，因为“test”是原始类型
+=======
+// can't use a string as the key
+weakMap.set("test", "Whoops"); // Error, because "test" is not an object
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 */!*
 ```
 
@@ -306,21 +356,32 @@ john = null; // 覆盖引用
 
 把它和上面普通 `Map` 的例子对比一下。现在，如果 `john` 仅作为 `WeakMap` 的键 —— 它将会被自动删除。
 
+<<<<<<< HEAD
 ...并且 `WeakMap` 并不支持方法 `keys()`，`values()`，`entries()`，我们不能对它进行迭代。所以没有办法获取它的所有键值。
+=======
+`WeakMap` does not support iteration and methods `keys()`, `values()`, `entries()`, so there's no way to get all keys or values from it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `WeakMap` 仅有如下方法：
 
 - `weakMap.get(key)`
 - `weakMap.set(key, value)`
-- `weakMap.delete(key, value)`
+- `weakMap.delete(key)`
 - `weakMap.has(key)`
 
+<<<<<<< HEAD
 为什么会有这些限制？这是处于一些技术原因。如果一个对象没有任何引用（就像上面代码中的 `john`），那么它将会被自动删除。但是从技术上讲，它没有完全指定**什么时候清理会发生**。
 
 JavaScript 引擎将会决定何时清理。它可能会选择马上清理内存或者等待：当更多需要删除操作发生的时候再删除。所以，技术上说，目前 `WeakMap` 中元素个数并不可知。引擎可能已经清理，也可能没有，也可能只进行了部分的清理。处于这个原因，允许访问 `WeakMap` 整体的方法并不支持。
+=======
+Why such a limitation? That's for technical reasons. If an object has lost all other references (like `john` in the code above), then it is to be garbage-collected automatically. But technically it's not exactly specified *when the cleanup happens*.
+
+The JavaScript engine decides that. It may choose to perform the memory cleanup immediately or to wait and do the cleaning later when more deletions happen. So, technically the current element count of a `WeakMap` is not known. The engine may have cleaned it up or not, or did it partially. For that reason, methods that access `WeakMap` as a whole are not supported.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 现在，我们在哪里需要这样的结构？
 
+<<<<<<< HEAD
 `WeakMap` 的目的是，我们可以当且仅当该对象存在时，为对象存储一些内容。但我们并不会因为存储了对象的一些内容，就强制对象一直保留在内存中。
 
 ```js
@@ -329,12 +390,28 @@ weakMap.put(john, "secret documents");
 ```
 
 当我们对对象有个主存储区，并且需要保存仅当对象活跃时候才相关的附加信息时，这一点就很有用了。
+=======
+The idea of `WeakMap` is that we can store something for an object that should exist only while the object exists. But we do not force the object to live by the mere fact that we store something for it.
+
+```js
+weakMap.set(john, "secret documents");
+// if john dies, secret documents will be destroyed automatically
+```
+
+That's useful for situations when we have a main storage for the objects somewhere and need to keep additional information, that is only relevant while the object lives.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 让我们看一个例子。
 
+<<<<<<< HEAD
 例如，我们写了一段代码来保存每个用户的访问次数。信息保存在一个 map 中：用户是键，访问次数是值。当用户离开了，我们也就不再需要保存他的访问次数了。
 
 有一个方法可以追踪离开的游客并手动清理记录：
+=======
+For instance, we have code that keeps a visit count for each user. The information is stored in a map: a user is the key and the visit count is the value. When a user leaves, we don't want to store their visit count anymore.
+
+One way would be to keep track of users, and when they leave -- clean up the map manually:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let john = { name: "John" };
@@ -352,7 +429,11 @@ john = null;
 // 但是记录依旧在 map 中，我们需要清理它！
 */!*
 alert( visitsCountMap.size ); // 1
+<<<<<<< HEAD
 // 它还在内存中，因为 Map 将它作为键
+=======
+// and john is also in the memory, because Map uses it as the key
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 另一个方法是使用 `WeakMap`：
@@ -371,17 +452,33 @@ john = null;
 // 所以这个对象会自动的从内存和 visitsCountMap 中删除
 ```
 
+<<<<<<< HEAD
 使用普通的 `Map`，用户离开后的数据清理是一很乏味的任务：我们不仅要从主存储区移除用户（可能是变量或者数组），还需要将附加的数据存储例如 `visitsCountMap` 也清除。当用户在代码的一个位置进行管理，而附加结构位于另一个位置，并且没有获取有关清除的信息这样的复杂的情况下，这种操作就很笨重。
 
 `WeakMap` 能让事情简单很多，因为它能够自动清理。它里面诸如上面的例子中来访次数这样的信息，当且仅当对象键存在的时候才存在。
+=======
+With a regular `Map`, cleaning up after a user has left becomes a tedious task: we not only need to remove the user from its main storage (be it a variable or an array), but also need to clean up the additional stores like `visitsCountMap`. And it can become cumbersome in more complex cases when users are managed in one place of the code and the additional structure is in another place and is getting no information about removals.
+
+```summary
+`WeakMap` can make things simpler, because it is cleaned up automatically. The information in it like visits count in the example above lives only while the key object exists.
+```
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `WeakSet` 的行为类似：
 
+<<<<<<< HEAD
 - 它和 `Set` 类似，但是我们仅能将对象添加进 `WeakSet`（不可以是基础类型）
 - 仅当对象存在其他位置的引用时它才存在于 set 中。
 - 就像 `Set` 一样，它支持 `add`，`has` 和 `delete`，不支持 `size`，`keys()` 也不支持迭代器。
 
 例如，我们可以用它来追踪一个项目是否被检查过：
+=======
+- It is analogous to `Set`, but we may only add objects to `WeakSet` (not primitives).
+- An object exists in the set while it is reachable from somewhere else.
+- Like `Set`, it supports `add`, `has` and `delete`, but not `size`, `keys()` and no iterations.
+
+For instance, we can use it to keep track of whether a message is read:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 let messages = [
@@ -393,22 +490,45 @@ let messages = [
 // 用数组的元素来填充（3 个元素）
 let unreadSet = new WeakSet(messages);
 
+<<<<<<< HEAD
 // 我们可以使用 unreadSet 来看一个 message 是否未读
 alert(unreadSet.has(messages[1])); // true
 // 读过之后就将它从 set 中移除
+=======
+// use unreadSet to see whether a message is unread
+alert(unreadSet.has(messages[1])); // true
+
+// remove it from the set after reading
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 unreadSet.delete(messages[1]); // true
 
 // 当我们对消息列表做 shift 操作，set 就会自动清理
 messages.shift();
+<<<<<<< HEAD
 // 不需要清理 unreadSet，它现在还有两个元素
 // 可惜并没有方法可以获取元素数目，所以无法显示出来
 ```
 
 `WeakMap` 和 `WeakSet` 最显著的限制就是没有迭代器，也不能获取当前所有内容。这可能会有点不方便，但是实际上并不妨碍 `WeakMap/WeakSet` 的主要任务 —— 作为对象的附加存储，该对象在其他位置被保存或管理。
+=======
+
+*!*
+// no need to clean unreadSet, it now has 2 items
+*/!*
+// (though technically we don't know for sure when the JS engine clears it)
+```
+
+The most notable limitation of `WeakMap` and `WeakSet` is the absence of iterations, and inability to get all current content. That may appear inconvenient, but does not prevent `WeakMap/WeakSet` from doing their main job -- be an "additional" storage of data for objects which are stored/managed at another place.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 总结
 
+<<<<<<< HEAD
 - `Map` —— 是一个键值对集合
+=======
+Regular collections:
+- `Map` -- is a collection of keyed values.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     和普通 `Object` 的区别：
 
@@ -421,7 +541,13 @@ messages.shift();
     - 和 array 不同，set 不允许元素重新排序。
     - 保持插入的顺序。
 
+<<<<<<< HEAD
 - `WeakMap` —— `Map` 的一个变体，仅允许对象作为键，并且当对象由于其他原因不可引用的时候将其删除。
+=======
+Collections that allow garbage-collection:
+
+- `WeakMap` -- a variant of `Map` that allows only objects as keys and removes them once they become inaccessible by other means.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     - 它不支持整体的操作：没有 `size` 属性，没有 `clear()` 方法，没有迭代器。
 
@@ -429,4 +555,8 @@ messages.shift();
 
     - 同样不支持 `size/clear()` 和迭代器。
 
+<<<<<<< HEAD
 `WeakMap` 和 `WeakSet` 被用作主要对象存储的次要数据结构补充。一旦对象从存储移除，那么存在于 `WeakMap/WeakSet` 的数据将会被自动清除。
+=======
+`WeakMap` and `WeakSet` are used as "secondary" data structures in addition to the "main" object storage. Once the object is removed from the main storage, if it is only found in the `WeakMap/WeakSet`, it will be cleaned up automatically.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 e69de29bb2..27a7b418ab 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 3ba7685ac0..ece5862c49 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/1-destruct-user/task.md b/1-js/05-data-types/09-destructuring-assignment/1-destruct-user/task.md
index f3e3704324..b2213323ac 100644
--- a/1-js/05-data-types/09-destructuring-assignment/1-destruct-user/task.md
+++ b/1-js/05-data-types/09-destructuring-assignment/1-destruct-user/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# 解构赋值
+# Destructuring assignment
 
-有以下对象：
+We have an object:
 
 ```js
 let user = {
@@ -13,18 +13,18 @@ let user = {
 };
 ```
 
-写一个解构赋值语句使得：
+Write the destructuring assignment that reads:
 
-- `name` 属性赋值给变量 `name`。
-- `years` 属性赋值给 `age`。
-- `isAdmin` 属性赋值给变量 `isAdmin`（如果属性缺失则赋值为 false）。
+- `name` property into the variable `name`.
+- `years` property into the variable `age`.
+- `isAdmin` property into the variable `isAdmin` (false if absent)
 
-赋值语句后的值必须是：
+The values after the assignment should be:
 
 ```js
 let user = { name: "John", years: 30 };
 
-// 等号左侧是你的代码
+// your code to the left side:
 // ... = user
 
 alert( name ); // John
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 d95cf1b1e5..f4bd5c761c 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 5e7e7b42b6..15eea1cb57 100644
--- a/1-js/05-data-types/09-destructuring-assignment/article.md
+++ b/1-js/05-data-types/09-destructuring-assignment/article.md
@@ -31,8 +31,13 @@ alert(surname);  // Kantor
 let [firstName, surname] = "Ilya Kantor".split(' ');
 ```
 
+<<<<<<< HEAD
 ````smart header="\"解构\"并不意味着\"破坏\""
 这种语法叫做“解构赋值”，因为它通过将结构中的各元素复制到变量中来达到“解构”的目的。但数组本身是没有被修改的。
+=======
+````smart header="\"Destructuring\" does not mean \"destructive\"."
+It's called "destructuring assignment," because it "destructurizes" by copying items into variables. But the array itself is not modified.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 也就是以下代码的更精简写法而已：
 ```js
@@ -42,6 +47,7 @@ let surname = arr[1];
 ```
 ````
 
+<<<<<<< HEAD
 ````smart header="忽略第一个元素"
 数组中不想要的元素也可以通过添加额外的逗号来把它丢弃：
 
@@ -49,12 +55,25 @@ let surname = arr[1];
 *!*
 // 不需要第一个和第二个元素
 let [, , title] = ["Julius", "Caesar", "Consul", "of the Roman Republic"];
+=======
+````smart header="Ignore elements using commas"
+Unwanted elements of the array can also be thrown away via an extra comma:
+
+```js run
+*!*
+// second element is not needed
+let [firstName, , title] = ["Julius", "Caesar", "Consul", "of the Roman Republic"];
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 */!*
 
 alert( title ); // Consul
 ```
 
+<<<<<<< HEAD
 在以上的代码中，数组的第一个和第二个元素被跳过，第三个元素被赋值给了 `title` 变量，剩下的元素也被跳过了。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ````
 
 ````smart header="用于等号右侧的任何可迭代对象"
@@ -128,6 +147,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
@@ -146,6 +166,7 @@ let [firstName, surname] = [];
 */!*
 
 alert(firstName); // undefined
+alert(surname); // undefined
 ```
 
 如果我们想要提供一个“默认值”给未赋值的变量，我们可以使用 `=` 来提供：
@@ -335,7 +356,11 @@ let title, width, height;
 }
 ```
 
+<<<<<<< HEAD
 为了告诉 JavaScript 这不是一个代码块，我们可以把整个赋值表达式用括号 `(...)` 包起来：
+=======
+To show JavaScript that it's not a code block, we can wrap the whole assignment in parentheses `(...)`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let title, width, height;
@@ -383,6 +408,8 @@ alert(item2);  // Donut
 
 除了 `extra` 属性的整个 `options` 对象都能被赋值给对应的变量。
 
+Note that `size` and `items` itself is not destructured.
+
 ![](destructuring-complex.png)
 
 最终，我们得到了 `width`、`height`、`item1`、`item2` 和具有默认值的 `title` 变量。
@@ -407,7 +434,11 @@ function showMenu(title = "Untitled", width = 200, height = 100, items = []) {
 }
 ```
 
+<<<<<<< HEAD
 现实情况下的问题就是你怎么记得住这么多参数的顺序，通常集成开发环境工具（IDE）会尽力帮助我们，特别是当代码有良好的文档注释的时候，但… 另一个问题就是当大部分的参数采用默认值就好的情况下，怎么调用这个函数。
+=======
+In real-life, the problem is how to remember the order of arguments. Usually IDEs try to help us, especially if the code is well-documented, but still... Another problem is how to call a function when most parameters are ok by default.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 难道像这样？
 
@@ -503,7 +534,11 @@ showMenu(); // Menu 100 200
     let {prop : varName = default, ...} = object
     ```
 
+<<<<<<< HEAD
     这表示属性 `prop` 会被赋值给变量 `varName`，如果没有这个属性的话，就会使用 `default` 的值。
+=======
+    This means that property `prop` should go into the variable `varName` and, if no such property exists, then the `default` value should be used.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - 解构数组的语法：
 
@@ -511,6 +546,10 @@ showMenu(); // Menu 100 200
     let [item1 = default, item2, ...rest] = array
     ```
 
+<<<<<<< HEAD
     数组的第一个元素赋值给 `item1`，第二个元素赋值给 `item2`，剩下的所有组成另一个数组 `rest`。
+=======
+    The first item goes to `item1`; the second goes into `item2`, all the rest makes the array `rest`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - 更多复杂的案例情况下，等号左侧必须和等号右侧有相同的结构。
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 50c4ffc93a..c46bf6e45c 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 bb908281df..26032a3d62 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 3ffff7c6e7..8c76ef6384 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 @@
 
 我们创建一个星期数组，这样可以通过它的序号得到名称：
 
-```js run
+```js run demo
 function getWeekDay(date) {
   let days = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
 
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 58f81bb35d..6b1e67d005 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,3 +1,4 @@
+<<<<<<< HEAD
 ```js run
 function getLocalDay(date) {
 
@@ -12,3 +13,5 @@ function getLocalDay(date) {
 
 alert( getLocalDay(new Date(2012, 0, 3)) ); // 2
 ```
+=======
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/1-js/05-data-types/10-date/3-weekday/task.md b/1-js/05-data-types/10-date/3-weekday/task.md
index 353a34ba1e..1c043ceb4e 100644
--- a/1-js/05-data-types/10-date/3-weekday/task.md
+++ b/1-js/05-data-types/10-date/3-weekday/task.md
@@ -4,7 +4,11 @@ importance: 5
 
 # 欧洲的星期表示方法
 
+<<<<<<< HEAD
 欧洲国家的星期计算是从星期一（数字 1）开始，然后星期二（数字 2），直到星期日（数字 7）。写一个函数 `getLocalDay(date)`，返回日期的欧洲式星期数。
+=======
+European countries have days of week starting with Monday (number 1), then Tuesday (number 2) and till Sunday (number 7). Write a function `getLocalDay(date)` that returns the "European" day of week for `date`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js no-beautify
 let date = new Date(2012, 0, 3);  // 3 Jan 2012
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 08f5d35784..b5afa2980a 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) {
 
 要实现这一点，我们可以复制这个日期，就像这样：
 
-```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 65f61c5bae..4f642536e1 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,5 @@
 Let's create a date using the next month, but pass zero as the day:
-```js run
+```js run demo
 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 2af9ae5802..583a1f4976 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 @@ alert( getSecondsToday() );
 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 124c143190..34dc3f4092 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 @@
 为获取 `date` 距离当前时间的间隔 —— 我们将两个日期相减。
 
-```js run
+```js run demo
 function formatDate(date) {
   let diff = new Date() - date; // 差值用毫秒表示
 
@@ -57,12 +57,18 @@ function formatDate(date) {
   let diffSec = Math.round(diffMs / 1000);
   let diffMin = diffSec / 60;
   let diffHour = diffMin / 60;
+<<<<<<< HEAD
       
   // 格式化
   year = year.toString().slice(-2);
+=======
+
+  // formatting
+  year = year.toString().slice(-2);
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
   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 8fed5dfb9d..3dbf9b98a2 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 @@
 
 让我一起探讨一个新的内置对象：[日期](mdn:js/Date)。该对象存储日期、时间以及提供管理它们的方法。
 
+<<<<<<< HEAD
 举个例子，我们可以使用它来存储创建、修改事件的时间，或者用来度量时间开销，再或者用来打印当前时间。
+=======
+For instance, we can use it to store creation/modification times, to measure time, or just to print out the current date.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 创建
 
@@ -39,7 +43,13 @@
 
     ```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,7 +118,11 @@ alert( date.getHours() );
 alert( date.getUTCHours() );
 ```
 
+<<<<<<< HEAD
 在以上给出的方法中，有两个与众不同的，它们没有 UTC 版本：
+=======
+Besides the given methods, there are two special ones that do not have a UTC-variant:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 [getTime()](mdn:js/Date/getTime)
 : 返回日期的时间戳 —— 从 1970-1-1 00:00:00 UTC+0 开始的毫秒数。
@@ -418,4 +432,8 @@ alert(`Loading started ${performance.now()}ms ago`);
 // 小数点后超过 3 位是错误，只有前三位是正确的
 ```
 
+<<<<<<< HEAD
 Node.JS 拥有 `microtime` 模块以及其他方法。从技术上来说，任何设备和环境都允许获取更精确的数值，不只是 `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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/1-js/05-data-types/11-json/article.md b/1-js/05-data-types/11-json/article.md
index e7127b9c0e..adfa1f7fe0 100644
--- a/1-js/05-data-types/11-json/article.md
+++ b/1-js/05-data-types/11-json/article.md
@@ -66,10 +66,17 @@ alert(json);
 
 方法 `JSON.stringify(student)` 接受对象并将其转换为一个字符串。
 
+<<<<<<< HEAD
 得到的 `json` 字符串是一个被称为 **JSON 编码**或者**序列化**或者**字符串化**或者**编组**的对象。我们准备好通过网线传输或存储。
 
 
 请注意，JSON 编码的对象与对象字面量有几个重要的区别：
+=======
+The resulting `json` string is called a *JSON-encoded* or *serialized* or *stringified* or *marshalled* object. We are ready to send it over the wire or put into a plain data store.
+
+
+Please note that a JSON-encoded object has several important differences from the object literal:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - 字符串使用双引号。JSON 中没有单引号或反引号。所以 `'John'` 转成 `"John"`。
 - 对象属性名称也是双引号的。这是强制性的。所以 `age:30` 转成 `"age":30`。
@@ -131,7 +138,7 @@ let meetup = {
   title: "Conference",
 *!*
   room: {
-    number: 123,
+    number: 23,
     participants: ["john", "ann"]
   }
 */!*
@@ -190,7 +197,11 @@ replacer
 space
 : 文本添加缩进、空格和换行符
 
+<<<<<<< HEAD
 大部分情况，`JSON.stringify` 仅与第一个参数一起使用。但是，如果我们需要微调替换过程，比如过滤掉循环引用，我们可以使用 `JSON.stringify` 的第二个参数。
+=======
+Most of the time, `JSON.stringify` is used with the first argument only. But if we need to fine-tune the replacement process, like to filter out circular references, we can use the second argument of `JSON.stringify`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如果我们传递一组属性给它，只有这一组属性会被编码
 
@@ -244,7 +255,11 @@ alert( JSON.stringify(meetup, *!*['title', 'participants', 'place', 'name', 'num
 
 幸运的是，我们也可以使用一个函数作为 `replacer`。
 
+<<<<<<< HEAD
 该函数将调用每个 `(key,value)` 对，并且返回 “replacement” 值，它将被用来代替原来的值。
+=======
+The function will be called for every `(key, value)` pair and should return the "replaced" value, which will be used instead of the original one.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在我们的例子中，除 `occupiedBy` 外我们都可以按照原样返回 `value`。要忽略 `occupiedBy`，下面的代码返回 `undefined`：
 
@@ -281,7 +296,11 @@ number:       23
 
 请注意 `replacer` 函数获取包括嵌套对象和数组项的每个键/值对。它被递归地应用。`replacer` 里面 `this` 的值是包含当前属性的对象。
 
+<<<<<<< HEAD
 第一个调用很特别。它是使用特殊的“包装对象”制作的： `{"": meetup}`。换句话说，第一个 `(key,value)` 对是空键，并且该值是整个目标对象。这就是为什么上面的例子中第一行是 `":[object Object]"` 的原因。
+=======
+The first call is special. It is made using a special "wrapper object": `{"": meetup}`. In other words, the first `(key, value)` pair has an empty key, and the value is the target object as a whole. That's why the first line is `":[object Object]"` in the example above.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 基于这个理念为 `replacer` 提供了更强大的功能：如有必要，它有机会分析和替换/跳过整个对象。
 
@@ -332,7 +351,11 @@ alert(JSON.stringify(user, null, 2));
 
 ## 定制 "toJSON"
 
+<<<<<<< HEAD
 像 `toString` 进行字符串转换，对象可以提供 `toJSON` 方法来进行 JSON 转换。如果可用，`JSON.stringify` 会自动调用它。
+=======
+Like `toString` for string conversion, an object may provide method `toJSON` for to-JSON conversion. `JSON.stringify` automatically calls it if available.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如：
 
@@ -361,7 +384,11 @@ alert( JSON.stringify(meetup) );
 
 在这里我们可以看到 `date` `(1)` 变成了一个字符串。这是因为所有日期都有一个内置的 `toJSON` 方法来返回这种类型的字符串。
 
+<<<<<<< HEAD
 现在让我们为对象 `room` 添加一个自定义的 `toJSON`：
+=======
+Now let's add a custom `toJSON` for our object `room` `(2)`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let room = {
@@ -409,7 +436,11 @@ str
 : JSON 字符串解析。
 
 reviver
+<<<<<<< HEAD
 : 将为每个 `(key,value)` 对调用的可选函数（键，值）进行转换。
+=======
+: Optional function(key,value) that will be called for each `(key, value)` pair and can transform the value.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如：
 
@@ -520,8 +551,16 @@ alert( schedule.meetups[1].date.getDate() ); // works!
 
 ## 总结
 
+<<<<<<< HEAD
 - JSON 是一种数据格式，对于大多数编程语言都有自己的独立标准和库。
 - JSON 支持 objects，arrays，strings，numbers，booleans 和 `null`。
 - JavaScript 提供序列化成 JSON 的方法 [JSON.stringify](mdn:js/JSON/stringify)和解析 JSON 方法 [JSON.parse](mdn:js/JSON/parse)。
 - 这两种方法都支持用于智能读/写的转换函数。
 - 如果一个对象具有 `toJSON`，那么它可被 `JSON.stringify` 调用。
+=======
+- JSON is a data format that has its own independent standard and libraries for most programming languages.
+- JSON supports plain objects, arrays, strings, numbers, booleans, and `null`.
+- JavaScript provides methods [JSON.stringify](mdn:js/JSON/stringify) to serialize into JSON and [JSON.parse](mdn:js/JSON/parse) to read from JSON.
+- Both methods support transformer functions for smart reading/writing.
+- If an object has `toJSON`, then it is called by `JSON.stringify`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 0a26e0a679..2686664249 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 b5f6a40129..a8f2cd6094 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 c45418ff4d..d0d37e35e7 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 6fc39ae130..3a937c64cd 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/article.md b/1-js/06-advanced-functions/01-recursion/article.md
index bcc4af5f7e..62ce4dfa52 100644
--- a/1-js/06-advanced-functions/01-recursion/article.md
+++ b/1-js/06-advanced-functions/01-recursion/article.md
@@ -318,9 +318,15 @@ let company = {
 
 或者说，一家公司有很多部门。
 
+<<<<<<< HEAD
 - 一个部门有员工列表，比如，`销售`部有 2 名员工：John 和 Alice。
 - 或者一个部门可能划分为几个子部门，比如`开发`有两个分支：`网站`和`内部`，它们都有自己的员工。
 - 当一个子部门增长时，它可能会划分为子部门（或者团队）。
+=======
+- A department may have an array of staff. For instance, `sales` department has 2 employees: John and Alice.
+- Or a department may split into subdepartments, like `development` has two branches: `sites` and `internals`. Each of them has their own staff.
+- It is also possible that when a subdepartment grows, it divides into subsubdepartments (or teams).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     比如，`网站`部门在未来可能会分为`网站 A` 和 `网站 B`。它们可能还会再分，没有图示，脑补一下吧。
 
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 000a80da8c..c694e7021f 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 5a2368694f..1fe50ace43 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 477989ad8a..b4c89ecdf0 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 41de7661c4..6b5b95a0fa 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 ac22034905..310a360665 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 201c66f150..2de39ca4f5 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 64b6fb2b72..80fabffc6a 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 c28fa82594..1e6dc14839 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 30577f89c2..354f012714 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 c19973420d..22ae944108 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 2b90154090..b40783a9b4 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 261ab144ed..e37597128f 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 a5c7457f0d..37b93d09d8 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="Rest 参数必须放到参数列表的末尾"
 Rest 参数会收集参数列表中剩余的所有参数，所以下面这种用法是行不通的：
+=======
+````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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 function f(arg1, ...rest, arg2) { // ...rest 后面还有个 arg2？！
@@ -119,7 +124,13 @@ function f() {
 
 f(1); // 1
 ```
+<<<<<<< HEAD
 我们已经知道箭头函数自身是没有 `this` 的，现在我们更进一步还知道它缺少 `arguments` 这个特殊的对象。
+=======
+````
+
+As we remember, arrow functions don't have their own `this`. Now we know they don't have the special `arguments` object either.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## Spread 操作符（展开操作符） [#spread-operator]
 
@@ -135,7 +146,11 @@ alert( Math.max(3, 5, 1) ); // 5
 
 假如我们已有数组 `[3, 5, 1]`，我们该如何用它调用 `Math.max` 呢？
 
+<<<<<<< HEAD
 直接把数组“原样”传入是不会奏效的，因为 `Math.max` 期待你传入一系列的数值型参数，而不是单一的数组：
+=======
+Passing it "as is" won't work, because `Math.max` expects a list of numeric arguments, not a single array:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let arr = [3, 5, 1];
@@ -145,7 +160,11 @@ alert( Math.max(arr) ); // NaN
 */!*
 ```
 
+<<<<<<< HEAD
 毫无疑问我们不可能手动地去一一设置参数 `Math.max(arg[0], arg[1], arg[2])`，因为我们不确定需要设置多少个参数。待代码最终执行时，这个参数数组可能很大，也可能啥也没用。这样手动设置实为下策。
+=======
+And surely we can't manually list items in the code `Math.max(arr[0], arr[1], arr[2])`, because we may be unsure how many there are. As our script executes, there could be a lot, or there could be none. And that would get ugly.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 **Spread 操作符** 来拯救你了！它看起来和 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 87ac80b37d..cd18e62bdc 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
 为了使第二个括号有效，第一个（括号）必须返回一个函数。
+=======
+For the second parentheses to work, the first ones must return a function.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 就像这样：
 
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 0f9c9a3c8a..bd8525ede7 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
 
 编写一个像 `sum(a)(b) = a+b` 这样工作的 `sum` 函数。
 
+<<<<<<< HEAD
 是的，就是这种通过双括号的方式（并不是错误）。
+=======
+Yes, exactly this way, using double parentheses (not a mistype).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 举个例子：
 
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 020d44ac62..c191c1ad96 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
 
 # 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 d51e8167f8..8e39564ffe 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 e70edbd6d4..39cc13a422 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 ff1370eff6..065450c953 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() {
 
 作为结果，所有的 `shooter` 都是从外部词法环境获得同样一个值最后的 `i=10`。
 
+<<<<<<< HEAD
 修改起来是很简单的：
+=======
+We can fix it by moving the variable definition into the loop:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
-```js run
+```js run demo
 function makeArmy() {
 
   let shooters = [];
@@ -80,9 +84,15 @@ army[0](); // 0
 army[5](); // 5
 ```
 
+<<<<<<< HEAD
 现在正常工作了，因为`for (..) {...}` 内的代码块每次执行都会创建一个新的词法环境，其中具有对应的 `i` 的值。
 
 所以，现在 `i` 值的距离（显示数字的地方更近了。现在它不是在 `makeArmy()` 词法环境中，而是在对应的当前循环迭代的词法环境中。`shooter` 从它创建的位置获得值。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ![](lexenv-makearmy.png)
 
@@ -90,7 +100,6 @@ army[5](); // 5
 
 其他技巧也是可以的，让我们了解一下，以便让我们更好地理解这个问题：
 
-
 ```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 3dc10afabf..49e8fee7d5 100644
--- a/1-js/06-advanced-functions/03-closure/article.md
+++ b/1-js/06-advanced-functions/03-closure/article.md
@@ -1,9 +1,15 @@
 
 # 闭包
 
+<<<<<<< HEAD
 JavaScript 是一种非常面向函数的语言。它给我们很大的发挥空间。函数创建后，可以赋值给其他变量或作为参数传递给另一个函数，并在完全不同的位置进行调用。
 
 我们知道函数可以访问其外部变量；这是一个常用的特性。
+=======
+JavaScript is a very function-oriented language. It gives us a lot of freedom. A function can be created dynamically,  copied to another variable or passed as an argument to another function and called from a totally different place later.
+
+We know that a function can access variables outside of it, this feature is used quite often.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 但是当外部变量变化时会发生什么呢？函数获得的是最新的值还是创建时的值呢？
 
@@ -63,33 +69,59 @@ JavaScript 是一种非常面向函数的语言。它给我们很大的发挥空
 
 要了解究竟发生了什么，首先我们要来讨论一下『变量』究竟是什么？
 
+<<<<<<< HEAD
 在 JavaScript 中，每个运行的函数、代码块或整个程序，都有一个称为**词法环境（Lexical Environment）**的关联对象。
+=======
+In JavaScript, every running function, code block `{...}`, and the script as a whole have an internal (hidden) associated object known as the *Lexical Environment*.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 词法环境对象由两部分组成：
 
+<<<<<<< HEAD
 1. **环境记录（Environment Record）**—— 一个把所有局部变量作为其属性（包括一些额外信息，比如 `this` 值）的对象。
 2. **外部词法环境（outer lexical environment）**的引用 —— 通常是嵌套当前代码（当前花括号之外）之外代码的词法环境。
 
 所以，『变量』只是环境记录这个特殊内部对象的属性。『访问或修改变量』意味着『访问或改变词法环境的一个属性』。
+=======
+1. *Environment Record* -- an object that stores all local variables as its properties (and some other information like the value of `this`).
+2. A reference to the *outer lexical environment*, the one associated with the outer code.
+
+**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".**
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 举个例子，这段简单的代码中只有一个词法环境：
 
 ![lexical environment](lexical-environment-global.png)
 
+<<<<<<< HEAD
 这是一个所谓的与整个程序关联的全局词法环境。在浏览器中，所有的 `<script>` 标签都同享一个全局（词法）环境。
+=======
+This is a so-called global Lexical Environment, associated with the whole script.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在上图中，矩形表示环境记录（存放变量），箭头表示外部（词法环境）引用。全局词法环境没有外部（词法环境）引用，所以它指向了 `null`。
 
+<<<<<<< HEAD
 这是关于 `let` 变量（如何变化）的全程展示：
+=======
+Here's the bigger picture of what happens when a `let` changes:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ![lexical environment](lexical-environment-global-2.png)
 
 右侧的矩形演示在执行期间全局词法环境是如何变化的：
 
+<<<<<<< HEAD
 1. 执行开始时，词法环境为空。
 2. `let phrase` 定义出现。它没有被赋值，所以存为 `undefined`。
 3. `phrase` 被赋予了一个值。
 4. `phrase` 引用了一个新值。
+=======
+1. When the script starts, the Lexical Environment is empty.
+2. The `let phrase` definition appears. It has been assigned no value, so `undefined` is stored.
+3. `phrase` is assigned a value.
+4. `phrase` changes value.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 现在一切看起来都相当简单易懂，是吧？
 
@@ -100,7 +132,15 @@ JavaScript 是一种非常面向函数的语言。它给我们很大的发挥空
 
 ### 函数声明
 
+<<<<<<< HEAD
 函数声明不像 `let` （声明的）变量，代码执行到它们时，它们并不会执行，而是在词法环境创建完成后才会执行。对于全局词法环境来说，它意味着脚本启动的那一刻。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这就是为什么可以在（函数声明）的定义之前调用函数声明。
 
@@ -111,21 +151,30 @@ JavaScript 是一种非常面向函数的语言。它给我们很大的发挥空
 
 ### 内部和外部的词法环境
 
+<<<<<<< HEAD
 在调用中，`say()`用到了一个外部变量，那么让我们了解一下其中的细节。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 首先，当函数运行时，会自动创建一个新的函数词法环境。这是一条对于所有函数通用的规则。这个词法环境用于存储调用的局部变量和参数。
 
+For instance, for `say("John")`, it looks like this (the execution is at the line, labelled with an arrow):
+
 <!--
     ```js
     let phrase = "Hello";
-    
+
     function say(name) {
      alert( `${phrase}, ${name}` );
     }
-    
+
     say("John"); // Hello, John
     ```-->
 
+<<<<<<< HEAD
 下面是`say("John")`内执行时词汇环境的图示，线上标有一个箭头：
 
 ![lexical environment](lexical-environment-simple.png)
@@ -138,13 +187,34 @@ JavaScript 是一种非常面向函数的语言。它给我们很大的发挥空
 它的内部词法环境有**外部**引用（指向）外部的那个。
 
 **当代码试图访问一个变量时 —— 它首先会在内部词法环境中进行搜索，然后是外部环境，然后是更外部的环境，直到（词法环境）链的末尾。**
+=======
+![lexical environment](lexical-environment-simple.png)
+
+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 property: `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 global one.**
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在严格模式下，变量未定义会导致错误。在非严格模式下，为了向后兼容，给未定义的变量赋值会创建一个全局变量。
 
 让我们看看例子中的查找是如何进行的：
 
+<<<<<<< HEAD
 - 当 `say` 中的 `alert` 试图访问 `name` 时，它立即在函数词法环境中被找到。
 - 当它试图访问 `phrase` 时，然而内部没有 `phrase` ，所以它追踪**外部**引用并在全局中找到它。
+=======
+- 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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ![lexical environment lookup](lexical-environment-simple-lookup.png)
 
@@ -173,9 +243,15 @@ sayHi(); // Pete
 
 上述代码的执行流程：
 
+<<<<<<< HEAD
 1. 全局词法环境中有 `name: "John"`。
 2. 在 `(*)` 那一行，全局变量已经变化，现在它为 `name: "Pete"`。
 3. 当函数 `say()` 执行时，它从外部获得 `name`。它取自全局词法环境，它已经变为 `"Pete"` 了。
+=======
+1. The global Lexical Environment has `name: "John"`.
+2. At the line `(*)` the global variable is changed, now it has `name: "Pete"`.
+3. When the function `sayHi()`, is executed and takes `name` from outside. Here that's from the global Lexical Environment where it's already `"Pete"`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 
 ```smart header="一次调用 —— 一个词法环境"
@@ -211,11 +287,19 @@ function sayHiBye(firstName, lastName) {
 }
 ```
 
+<<<<<<< HEAD
 这里创建的**嵌套**函数 `getFullName()` 是为了方便说明。它可以访问外部变量，因此可以返回全名。
 
 更有意思的是，可以返回一个嵌套函数：把它作为一个新对象的属性（如果外部函数创建一个有方法的对象）或是将其直接作为结果返回。其后可以在别处调用它。不论在哪里进行调用到它，它仍可以访问同样的外部变量。
 
 一个构造函数的例子（请参考 <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):
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 // 构造函数返回一个新对象
@@ -228,17 +312,24 @@ function User(name) {
 }
 
 let user = new User("John");
+<<<<<<< HEAD
 user.sayHi(); // 该方法访问外部变量 "name"
 ```
 
 一个返回函数的例子：
+=======
+user.sayHi(); // the method "sayHi" code has access to the outer "name"
+```
+
+And here we just create and return a "counting" function:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 function makeCounter() {
   let count = 0;
 
   return function() {
-    return count++; // has access to the outer counter
+    return count++; // has access to the outer "count"
   };
 }
 
@@ -249,7 +340,11 @@ alert( counter() ); // 1
 alert( counter() ); // 2
 ```
 
+<<<<<<< HEAD
 让我们继续来看 `makeCounter` 这个例子。它返回一个函数，（返回的）该函数每次调用都会返回下一个数字。尽管它的代码很简单，但稍加变型就会有实际的用途，比如，作一个 [伪随机数生成器](https://en.wikipedia.org/wiki/Pseudorandom_number_generator) 等等。所以这个例子并不像看起来那么造作。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 计数器内部的工作是怎样的呢？
 
@@ -265,8 +360,13 @@ alert( counter() ); // 2
 
 这里有两个要考虑的问题：
 
+<<<<<<< HEAD
 1. 我们可以用某种方式在 `makeCounter` 以外的代码中改写 `counter` 吗？比如，在上例中的 `alert` 调用后。
 2. 如果我们多次调用 `makeCounter()` —— 它会返回多个 `counter` 函数。它们的 `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`?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在你继续读下去之前，请先回答这些问题。
 
@@ -276,8 +376,13 @@ alert( counter() ); // 2
 
 好吧，我们来重复一下答案。
 
+<<<<<<< HEAD
 1. 这是不可能做到的。`counter` 是一个局部函数的变量，我们不能从外部访问它。
 2. `makeCounter()` 的每次调用都会创建一个拥有独立 `counter` 的新词法环境。因此得到的 `counter` 是独立的。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 下面是一个例子：
 
@@ -299,13 +404,23 @@ alert( counter2() ); // 0 （独立的）
 ```
 
 
+<<<<<<< HEAD
 希望现在你对外部变量的情况相当清楚了。但对于更复杂的情况，可能需要更深入的理解。所以让我们更加深入吧。
+=======
+Hopefully, the situation with outer variables is clear now. For most situations such understanding is enough. There are few details in the specification that we omitted for brevity. So in the next section we cover even more details, not to miss anything.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 环境详情
 
+<<<<<<< HEAD
 现在你大概已经了解闭包的工作原理了，我们可以探讨一下实际问题了。
 
 以下是 `makeCounter` 的执行过程，遵循它确保你理解所有的内容。请注意我们还没有介绍另外的 `[[Environment]]` 属性。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 1. 在脚本开始时，只存在全局词法环境：
 
@@ -313,13 +428,21 @@ alert( counter2() ); // 0 （独立的）
 
     在开始时里面只有一个 `makeCounter` 函数，因为它是一个函数声明。它还没有执行。
 
+<<<<<<< HEAD
     所有的函数在『诞生』时都会根据创建它的词法环境获得隐藏的 `[[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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     在这里，`makeCounter` 创建于全局词法环境，那么 `[[Environment]]` 中保留了它的一个引用。
 
     换句话说，函数会被创建处的词法环境引用『盖章』。隐藏函数属性 `[[Environment]]` 中有这个引用。
 
+<<<<<<< HEAD
 2. 代码执行，`makeCounter()` 被执行。下图是当 `makeCounter()` 内执行第一行瞬间的快照：
+=======
+2. The code runs on, the new global variable `counter` is declared and for its value `makeCounter()` is called. Here's a snapshot of the moment when the execution is on the first line inside `makeCounter()`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ![](lexenv-nested-makecounter-2.png)
 
@@ -339,7 +462,11 @@ alert( counter2() ); // 0 （独立的）
 
     ![](lexenv-nested-makecounter-3.png)
 
+<<<<<<< HEAD
     请注意在这一步中，内部函数并没有被立即调用。 `function() { return count++; }` 内的代码还没有执行，我们要返回它。
+=======
+    Please note that on this step the inner function was created, but not yet called. The code inside `function() { return count++; }` is not running.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 4. 随着执行的进行，`makeCounter()` 调用完成，并且将结果（该嵌套函数）赋值给全局变量 `counter`。
 
@@ -380,7 +507,11 @@ alert( counter2() ); // 0 （独立的）
 ```smart header="闭包"
 开发者应该有听过『闭包』这个编程术语。
 
+<<<<<<< HEAD
 函数保存其外部的变量并且能够访问它们称之为[闭包](https://en.wikipedia.org/wiki/Closure_(computer_programming))。在某些语言中，是没有闭包的，或是以一种特别方式来实现。但正如上面所说的，在 JavaScript 中函数都是天生的闭包（只有一个例外，请参考 <info:new-function>）。
+=======
+A [closure](https://en.wikipedia.org/wiki/Closure_(computer_programming)) is a function that remembers its outer variables and can access them. In some languages, that's not possible, or a function should be written in a special way to make it happen. But as explained above, in JavaScript, all functions are naturally closures (there is only one exclusion, to be covered in <info:new-function>).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 也就是说，他们会通过隐藏的 `[[Environment]]` 属性记住创建它们的位置，所以它们都可以访问外部变量。
 
@@ -389,18 +520,28 @@ alert( counter2() ); // 0 （独立的）
 
 ## 代码块和循环、IIFE
 
+<<<<<<< HEAD
 上面的例子都集中于函数。但对于 `{...}` 代码块，词法环境同样也是存在的
 
 当代码块中包含块级局部变量并运行时，会创建词法环境。这里有几个例子。
+=======
+The examples above concentrated on functions. But a Lexical Environment exists for any code block `{...}`.
 
-## If
+A Lexical Environment is created when a code block runs and contains block-local variables. Here are a couple of examples.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
+### If
+
+<<<<<<< HEAD
 在上面的例子中，当代码执行入 `if` 块，新的 "if-only" 词法环境就会为此而创建：
+=======
+In the example below, the `user` variable exists only in the `if` block:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 <!--
     ```js run
     let phrase = "Hello";
-    
+
     if (true) {
         let user = "John";
 
@@ -412,11 +553,17 @@ alert( counter2() ); // 0 （独立的）
 
 ![](lexenv-if.png)
 
+<<<<<<< HEAD
 新的词法环境是封闭的作为其外部引用，所以可以找到 `phrase`。但在 `if` 内声明的变量和函数表达式都保留在该词法环境中，从外部是无法被访问到的。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如，在 `if` 结束后，下面的 `alert` 是访问不到 `user` 的，因为会发生错误。
 
-## For, while
+### For, while
 
 对于循环而言，每次迭代都有独立的词法环境。如果在 `for` 循环中声明变量，那么它在词法环境中是局部的：
 
@@ -429,15 +576,25 @@ for (let i = 0; i < 10; i++) {
 alert(i); // 错误，没有该变量
 ```
 
+<<<<<<< HEAD
 这实际上是个意外，因为 `let i` 看起来好像是在 `{...}` 外。但事实上，每一次循环执行都有自己的词法环境，其中包含着 `i`。
 
 在循环结束后，`i` 是访问不到的。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ### 代码块
 
 我们也可以使用『空』的代码块将变量隔离到『局部作用域』中。
 
+<<<<<<< HEAD
 比如，在 Web 浏览器中，所有脚本都共享同一个全局环境。如果我们在一个脚本中创建一个全局变量，对于其他脚本来说它也是可用的。但是如果两个脚本有使用同一个变量并且相互覆盖，那么这会成为冲突的根源。
+=======
+For instance, in a web browser all scripts (except with `type="module"`) share the same global area. So if we create a global variable in one script, it becomes available to others. But that becomes a source of conflicts if two scripts use the same variable name and overwrite each other.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如果变量名是一个被广泛使用的词，并且脚本作者可能彼此也不知道。
 
@@ -459,9 +616,19 @@ alert(message); // 错误：message 未定义
 
 ### IIFE
 
+<<<<<<< HEAD
 在旧的脚本中，我们可以找到一个所谓的『立即调用函数表达式』（简称为 IIFE）用于此目的。
 
 它们看起来像这样：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 (function() {
@@ -475,11 +642,19 @@ alert(message); // 错误：message 未定义
 
 这里创建了一个函数表达式并立即调用。因此代码拥有自己的私有变量并立即执行。
 
+<<<<<<< HEAD
 函数表达式被括号 `(function {...})` 包裹起来，因为在 JavaScript 中，当代码流碰到 `"function"` 时，它会把它当成一个函数声明的开始。但函数声明必须有一个函数名，所以会导致错误：
 
 ```js run
 // Error: Unexpected token (
 function() { // <-- JavaScript 找不到函数名，遇到 ( 导致错误
+=======
+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:
+
+```js run
+// Try to declare and immediately call a function
+function() { // <-- Error: Unexpected token (
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
   let message = "Hello";
 
@@ -488,28 +663,38 @@ function() { // <-- JavaScript 找不到函数名，遇到 ( 导致错误
 }();
 ```
 
+<<<<<<< HEAD
 我们可以说『好吧，让其变成函数声明，让我们增加一个名称』，但它是没有效果的。JavaScript 不允许立即调用函数声明。
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
-// syntax error because of brackets below
+// syntax error because of parentheses below
 function go() {
 
 }(); // <-- can't call Function Declaration immediately
 ```
 
+<<<<<<< HEAD
 因此，需要使用圆括号告诉给 JavaScript，这个函数是在另一个表达式的上下文中创建的，因此它是一个表达式。它不需要函数名也可以立即调用。
 
 在 JavaScript 中还有其他方式来定义函数表达式：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 // 创建 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,46 +710,70 @@ function go() {
 
 ## 垃圾收集
 
+<<<<<<< HEAD
 我们所讨论的词法环境和常规值都遵循同样的内存管理规则。
 
 - 通常，在函数运行后词法环境会被清理。举个例子：
+=======
+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;
+}
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
-    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
     这里的两个值都是词法环境的属性。但是在 `f()` 执行完后，该词法环境变成不可达，因此它在内存中已被清理。
 
 - ...但是如果有一个嵌套函数在 `f` 结束后仍可达，那么它的 `[[Environment]]` 引用会继续保持着外部词法环境存在：
+=======
+...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;
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
-      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
+```
 
+<<<<<<< HEAD
     let g = f(); // g 是可达的，并且将其外部词法环境保持在内存中
     ```
 
 - 请注意如果多次调用 `f()`，返回的函数被保存，那么其对应的词法对象同样也会保留在内存中。下面代码中有三个这样的函数：
+=======
+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:
 
-    ```js
-    function f() {
-      let value = Math.random();
+```js
+function f() {
+  let value = Math.random();
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
-      return function() { alert(value); };
-    }
+  return function() { alert(value); };
+}
+
+// 3 functions in array, every one of them links to Lexical Environment (LE for short)
+// from the corresponding f() run
+//         LE   LE   LE
+let arr = [f(), f(), f()];
+```
 
+<<<<<<< HEAD
     // 数组中的三个函数，每个都有词法环境相关联。
     // 来自对应的 f() 
     //         LE   LE   LE
@@ -572,21 +781,34 @@ function go() {
     ```
 
 - 词法环境对象在变成不可达时会被清理：当没有嵌套函数引用（它）时。在下面的代码中，在 `g` 变得不可达后，`value` 同样会被从内存中清除；
+=======
+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.
 
-    ```js
-    function f() {
-      let value = 123;
+In the code below, after `g` becomes unreachable, enclosing Lexical Environment (and hence the `value`) is  cleaned from memory;
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
-      function g() { alert(value); }
+```js
+function f() {
+  let value = 123;
 
-      return g;
-    }
+  function g() { alert(value); }
+
+  return g;
+}
 
+<<<<<<< HEAD
     let g = f(); // 当 g 存在时
     // 对应的词法环境可达
 
     g = null; // ...在内存中被清理
     ```
+=======
+let g = f(); // while g is alive
+// there corresponding Lexical Environment lives
+
+g = null; // ...and now the memory is cleaned up
+```
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ### 实际的优化
 
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 a27fb309ee..5a11b65de9 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 6da6f5b993..794676cda5 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 92a4603ca7..c6083a4520 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 0a5ea9e508..af57c51cdb 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 47038d18a8..dce67876f2 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 4a317c7fba..9bba88bc53 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 f8d8af0ea0..4d5a787c28 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 a926bce478..c7575f4d52 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 98eacdcc66..70b4a09bfd 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 46074276e8..4cc762c10d 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 527c41572e..7410dddc82 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 035dfd3144..103c66fb58 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 5a10a13482..44366ed782 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 684f017e40..36df7cadd2 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 aff8804d26..3bdf5108de 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 893724c1da..023dba05cd 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 47163aaa99..342bdae98c 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 240b010382..55306e6663 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 9d2284acab..1cd77f8acd 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 808b2f4458..3e256bbb91 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 c35f34917a..6899a777f4 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 5aa9432b50..91980cf84f 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 067300455c..56aafaf3d0 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 722aaba73f..f423b125ef 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 e6fd8b6ee8..2424fbf233 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 28e971b310..b206cbe8b9 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 392cb57120..1b641d48dc 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 870897d8d2..f06bc3ed80 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 66dd12614b..eac7e72b85 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 @@
 
 但是 `var` 却是一头源自旧时代的怪兽。在现代脚本中一般不再使用，但它仍存在于陈旧的脚本里。
 
+<<<<<<< HEAD
 如果你不打算见识这样的脚本，你可以跳过或推迟阅读这一章，但是你有可能会踩到它的坑。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 乍看之下，`var` 和 `let` 的行为相似，即声明变量：
 
@@ -74,7 +78,11 @@ sayHi();
 alert(phrase); // 报错：phrase is not defined
 ```
 
+<<<<<<< HEAD
 可以看到，`var` 穿透了 `if`、`for` 或其它块级代码。这是因为在早期的 JavaScript 里，块没有词法环境。而 `var` 就是对它的一个回忆。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## "var" 在函数开头被处理
 
@@ -182,4 +190,8 @@ sayHi();
 
 涉及全局对象时，还有一个小的区别，我们会在下一章讲解。
 
+<<<<<<< HEAD
 这些区别实际上很多时候都不是好事。首先，我们无法创建块级局部变量。而且变量提升会造成更多的错误。所以，在新近的脚本里，`var` 就很少见了。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 1b55bfda9a..fbf4396b1a 100644
--- a/1-js/06-advanced-functions/05-global-object/article.md
+++ b/1-js/06-advanced-functions/05-global-object/article.md
@@ -1,4 +1,5 @@
 
+<<<<<<< HEAD
 # 全局对象
 
 全局对象提供可在任何地方使用的变量和函数。大多数情况下，这些全局变量内置于语言或主机环境中。
@@ -44,14 +45,68 @@ window.alert("Hello");
     ```
 
     请注意，更现代的 `let / const` 声明不会发生这种情况：
+=======
+# Global object
+
+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.
+
+For instance, we can call `alert` as a method of `window`:
+
+```js run
+alert("Hello");
+
+// the same as
+window.alert("Hello");
+```
+
+We can reference other built-in functions like `Array` as `window.Array` and create our own properties on it.
+
+## Browser: the "window" object
+
+For historical reasons, in-browser `window` object is a bit messed up.
+
+1. It provides the "browser window" functionality, besides playing the role of a global object.
+
+    We can use `window` to access properties and methods, specific to the browser window:
+
+    ```js run
+    alert(window.innerHeight); // shows the browser window height
+
+    window.open('http://google.com'); // opens a new browser window
+    ```
+
+2. Top-level `var` variables and function declarations automatically become properties of `window`.
+
+    For instance:
+    ```js untrusted run no-strict refresh
+    var x = 5;
+
+    alert(window.x); // 5 (var x becomes a property of window)
+
+    window.x = 0;
+
+    alert(x); // 0, variable modified
+    ```
+
+    Please note, that doesn't happen with more modern `let/const` declarations:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js untrusted run no-strict refresh
     let x = 5;
 
+<<<<<<< HEAD
     alert(window.x); // undefined ("let" 不会创建窗口属性)
     ```
 
 3. 此外，所有脚本共享相同的全局作用域，因此在某一个 `<script>` 中声明的变量在其他的里面也可见：
+=======
+    alert(window.x); // undefined ("let" doesn't create a window property)
+    ```
+
+3. Also, all scripts share the same global scope, so variables declared in one `<script>` become visible in  another ones:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```html run
     <script>
@@ -65,12 +120,17 @@ window.alert("Hello");
     </script>
     ```
 
+<<<<<<< HEAD
 4. 而且，虽然是小问题但仍然重要的一点是：全局范围内 `this` 的值是 `window`。
+=======
+4. And, a minor thing, but still: the value of `this` in the global scope is `window`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```js untrusted run no-strict refresh
     alert(this); // window
     ```
 
+<<<<<<< HEAD
 为什么这样做？在语言创建时，将多个方面合并到单一 `window` 对象中的想法就是“简化”，但此后许多事情发生了变化，小型脚本变成了需要恰当构架的大型应用程序。
 
 不同脚本（可能来自不同的源）之间的变量可以互相访问好不好？
@@ -84,6 +144,21 @@ window.alert("Hello");
 如果我们在 `<script>` 标签上设置特性 `type="module"` ，那么这样的脚本被认为是个单独的“模块”，它有自己的顶级作用域（词法环境），不会干扰 `window`。
 
 - 在一个模块中，`var x` 不会成为 `window` 的属性：
+=======
+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.
+
+Is it good that different scripts (possibly from different sources) see variables of each other?
+
+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.
+
+As of now, the multi-purpose `window` is considered a design mistake in the language.
+
+Luckily, there's a "road out of hell", called "JavaScript modules".
+
+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`.
+
+- In a module, `var x` does not become a property of `window`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```html run
     <script type="module">
@@ -93,7 +168,11 @@ window.alert("Hello");
     </script>
     ```
 
+<<<<<<< HEAD
 - 两个模块的变量彼此不可见：
+=======
+- Two modules that do not see variables of each other:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```html run
     <script type="module">
@@ -102,11 +181,19 @@ window.alert("Hello");
 
     <script type="module">
       alert(window.x); // undefined
+<<<<<<< HEAD
       alert(x); // 错误：未声明的变量
     </script>
     ```
 
 - 然后最后一个小问题是，模块中 `this` 的顶级值是 `undefined`（为什么它一定得是 `window` ？）：
+=======
+      alert(x); // Error: undeclared variable
+    </script>
+    ```
+
+- And, the last minor thing, the top-level value of `this` in a module is `undefined` (why should it be `window` anyway?):
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     ```html run
     <script type="module">
@@ -114,6 +201,7 @@ window.alert("Hello");
     </script>
     ```
 
+<<<<<<< HEAD
 **使用 `<script type="module">` 后，通过将顶级作用域与 `window` 分开的方式来修复语言的设计缺陷。**
 
 稍后我们将在[模块](info:modules)一章中介绍模块的更多功能。
@@ -126,11 +214,26 @@ window.alert("Hello");
 
     ```js run
     // 明确地将它分配给 `window`
+=======
+**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).
+
+## Valid uses of the global object
+
+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).
+
+    Here we put the information about the current user into a global object, to be accessible from all other scripts:
+
+    ```js run
+    // explicitly assign it to `window`
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
     window.currentUser = {
       name: "John",
       age: 30
     };
 
+<<<<<<< HEAD
     // 然后，在另一个脚本中
     alert(window.currentUser.name); // John
     ```
@@ -139,12 +242,22 @@ window.alert("Hello");
 
     例如，测试是否存在内置的 `Promise` 对象（它不存在于非常旧的浏览器中）：
     
+=======
+    // then, elsewhere, in another script
+    alert(window.currentUser.name); // John
+    ```
+
+2. We can test the global object for support of modern language features.
+
+    For instance, test if a build-in `Promise` object exists (it doesn't in really old browsers):
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
     ```js run
     if (!window.Promise) {
       alert("Your browser is really old!");
     }
     ```
 
+<<<<<<< HEAD
 3. 我们可以创建 "polyfills"：添加环境不支持（比如旧的浏览器）但存在于现代标准中的功能。
 
     ```js run
@@ -154,3 +267,14 @@ window.alert("Hello");
     ```
 
 ...当然，如果我们在浏览器中使用 `window` 访问浏览器窗口（而不是全局对象）就完全没问题。
+=======
+3. We can create "polyfills": add functions that are not supported by the environment (say, an old browser), but exist in the modern standard.
+
+    ```js run
+    if (!window.Promise) {
+      window.Promise = ... // custom implementation of the modern language feature
+    }
+    ```
+
+...And of course, if we're in a browser, using `window` to access browser window features (not as a global object) is completely fine.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 1a101b69cd..63670241c1 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
@@ -6,9 +6,15 @@ importance: 5
 
 修改 `makeCounter()` 代码，使得 counter 可以减一和赋值：
 
+<<<<<<< HEAD
 - `counter()` 应该返回下一个数字（同以前逻辑）。
 - `counter.set(value)` 应该设置 `count` 为 `value`。
 - `counter.decrease(value)` 应该把 `count` 减 1。
+=======
+- `counter()` should return the next number (as before).
+- `counter.set(value)` should set the `count` to `value`.
+- `counter.decrease()` should decrease the `count` by 1.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 查看沙箱代码获取完整使用示例。
 
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 4cf427aa51..b98010351b 100644
--- a/1-js/06-advanced-functions/06-function-object/article.md
+++ b/1-js/06-advanced-functions/06-function-object/article.md
@@ -64,7 +64,11 @@ alert(user.sayHi.name); // sayHi
 alert(user.sayBye.name); // sayBye
 ```
 
+<<<<<<< HEAD
 这没有什么神奇的。有时会出现无法推测名字的情况。此时，属性 `name` 会是空，比如：
+=======
+There's no magic though. There are cases when there's no way to figure out the right name. In that case, the name property is empty, like here:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 // 函数在数组中创建
@@ -152,7 +156,11 @@ alert( `调用了 ${sayHi.counter} 次` ); // 调用了 2 次
 ```warn header="属性不是变量"
 一个被赋值的函数属性，比如 `sayHi.counter = 0` **没有**在函数内定义一个局部变量 `counter`。或者说，一个 `counter` 属性与一个 `let counter` 的变量是毫不相关的两个东西。
 
+<<<<<<< HEAD
 我们可以把函数当作对象，在它里面存储属性，但是这对它的执行没有任何影响。变量不会使用函数属性，反之亦然。它们是不相干的词。
+=======
+We can treat a function as an object, store properties in it, but that has no effect on its execution. Variables are not function properties and vice versa. These are just parallel worlds.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 函数属性有时会用来替代闭包。比如，我们可以将 <info:closure> 章节中计数函数的例子改写为用函数属性实现：
@@ -338,8 +346,13 @@ welcome(); // Hello, Guest（嵌套调用有效）
 
 我们介绍了它们的一些属性：
 
+<<<<<<< HEAD
 - `name` -- 函数的名字。不仅仅在函数定义指定时存在，而且在赋值或者对象属性中也会有。
 - `length` -- 函数定义时的入参个数。余参不参与计数。
+=======
+- `name` -- the function name. Usually taken from the function definition, but if there's none, JavaScript tries to guess it from the context (e.g. an assignment).
+- `length` -- the number of arguments in the function definition. Rest parameters are not counted.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如果函数是通过函数表达式被声明的（不是在主代码流里），它附带了名字，那么它被称为命名的函数表达式。可以用来在函数内部引用自己，或者递归调用等诸如此类场景。
 
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/solution.md b/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/solution.md
index 6dd1f65a79..77db31ff65 100644
--- a/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/solution.md
+++ b/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/solution.md
@@ -38,5 +38,31 @@ function printNumbers(from, to) {
 printNumbers(5, 10);
 ```
 
+<<<<<<< HEAD
 这两种解法在首次输出时都有一个初始的延时，需要的话可以加一行让其立即输出，这并不难。
+=======
+Note that in both solutions, there is an initial delay before the first output. The function is called after `1000ms` the first time.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
+If we also want the function to run immediately, then we can add an additional call on a separate line, like this:
+
+```js run
+function printNumbers(from, to) {
+  let current = from;
+
+  function go() {
+    alert(current);
+    if (current == to) {
+      clearInterval(timerId);
+    }
+    current++;
+  }
+
+*!*
+  go();
+*/!*
+  let timerId = setInterval(go, 1000);
+}
+
+printNumbers(5, 10);
+```
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 0183a47997..735a446f70 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 fe13f8916b..1d5e72da89 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);
   }
 
   // 任务的一部分
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 0b5cd4af17..5dba33adb2 100644
--- a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
+++ b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
@@ -4,8 +4,15 @@
 
 目前有两种方式可以实现：
 
+<<<<<<< HEAD
 - `setTimeout` 将函数的执行推迟到一段时间之后再执行。
 - `setInterval` 让函数间隔一定时间周期性执行。
+=======
+- `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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这两个方法并不存在于 JavaScript 的规范中。但是大多数运行环境都有内置的调度器，而且也提供了这两个方法的实现。目前来讲，所有浏览器，包括 Node.js 都支持这两个方法。
 
@@ -14,7 +21,7 @@
 用法：
 
 ```js
-let timerId = setTimeout(func|code, delay[, arg1, arg2...])
+let timerId = setTimeout(func|code, [delay], [arg1], [arg2], ...)
 ```
 
 参数说明：
@@ -24,7 +31,11 @@ let timerId = setTimeout(func|code, delay[, arg1, arg2...])
 一般传入的都是函数，介于某些历史原因，代码字符串也支持，但是不建议使用这种方式。
 
 `delay`
+<<<<<<< HEAD
 ：执行前的延时，以毫秒为单位（1000 毫秒 = 1 秒）；
+=======
+: The delay before run, in milliseconds (1000 ms = 1 second), by default 0.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `arg1`，`arg2`...
 ：要传入被执行函数（或代码字符串）的参数列表（IE9 以下不支持）
@@ -98,7 +109,11 @@ clearTimeout(timerId);
 alert(timerId); // 还是那个 id 没变（并没有因为调度被取消了而变成 null）
 ```
 
+<<<<<<< HEAD
 从 `alert` 的输出来看，定时器 id 在浏览器中是一串数字，然而在其他运行环境下可能是别的东西。就比如 Node.js 返回的是一个定时器对象，这个对象包含一系列方法。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 我再重申一遍，这俩方法没有统一的规范定义，但也无伤大雅。
 
@@ -109,7 +124,7 @@ alert(timerId); // 还是那个 id 没变（并没有因为调度被取消了而
 `setInterval` 方法和 `setTimeout` 的用法是相同的：
 
 ```js
-let timerId = setInterval(func|code, delay[, arg1, arg2...])
+let timerId = setInterval(func|code, [delay], [arg1], [arg2], ...)
 ```
 
 所有参数的意义也是相同的，不过相对于 `setTimeout` 只执行一次，`setInterval` 是每间隔一定时间周期性执行。
@@ -126,10 +141,17 @@ let timerId = setInterval(() => alert('tick'), 2000);
 setTimeout(() => { clearInterval(timerId); alert('stop'); }, 5000);
 ```
 
+<<<<<<< HEAD
 ```smart header="弹窗会让 Chrome/Opera/Safari 内的时钟停止"
 在众多浏览器中，IE 和 Firefox 在显示 `alert/confirm/prompt` 时，内部的定时器仍旧会继续滴答，但是在 Chrome、Opera 和 Safari 中，内部的定时器会暂停/冻结。
 
 所以，在执行以上代码时，如果在一定时间内没有关掉 `alert` 弹窗，那么在你关闭弹窗后，Firefox/IE 会立即显示下一个 `alert` 弹窗（前提是距离上一次执行超过了 2 秒），而 Chrome/Opera/Safari 这三个则需要再等待 2 秒以上的时间才会再显示（因为在 `alert` 弹窗期间，定时器并没有滴答）。
+=======
+```smart header="Time goes on while `alert` is shown"
+In most browsers, including Chrome and Firefox the internal timer continues "ticking" while showing `alert/confirm/prompt`.
+
+So if you run the code above and don't dismiss the `alert` window for some time, then in the next `alert` will be shown immediately as you do it. The actual interval between alerts will be shorter than 5 seconds.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ## 递归版 setTimeout
@@ -175,7 +197,11 @@ let timerId = setTimeout(function request() {
 ```
 
 
+<<<<<<< HEAD
 如果不时有一些占用 CPU 的任务，我们可以通过衡量执行时间来安排下次调用是应该提前还是推迟。
+=======
+And if we the functions that we're scheduling are CPU-hungry, then we can measure the time taken by the execution and plan the next call sooner or later.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 **递归版 `setTimeout` 能保证每次执行间的延时都是准确的，`setInterval` 却不能够。**
 
@@ -237,7 +263,11 @@ setTimeout(function() {...}, 100);
 
 ## setTimeout(...,0)
 
+<<<<<<< HEAD
 还有一种特殊的用法：`setTimeout(func, 0)`。
+=======
+There's a special use case: `setTimeout(func, 0)`, or just `setTimeout(func)`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这样调度可以让 `func` 尽快执行，但是只有在当前代码执行完后，调度器才会对其进行调用。
 
@@ -246,7 +276,7 @@ setTimeout(function() {...}, 100);
 下面例子中，代码会先输出 "Hello"，然后紧接着输出 "World"：
 
 ```js run
-setTimeout(() => alert("World"), 0);
+setTimeout(() => alert("World"));
 
 alert("Hello");
 ```
@@ -259,7 +289,11 @@ alert("Hello");
 
 譬如，一个语法高亮脚本（用来给示例代码着色）会占用非常大的 CPU 资源。为了给代码进行高亮显示，它首先要进行代码分析，然后创建一堆着色后的元素，再将其添加到页面文档中 —— 文本量很大时，耗费时间也会很长。有时候甚至会导致浏览器“挂起”，这种情况是显然不能接受的。
 
+<<<<<<< HEAD
 所以，我们不妨将长文本分割成几部分处理。首先处理前 100 行，然后用 `setTimeout(...,0)` 安排接下来 100 行的处理，以此类推。
+=======
+So we can split the long text into pieces. First 100 lines, then plan another 100 lines using `setTimeout(..., 0)`, and so on.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 为了方便理解，来考虑一个稍微简单点的例子。比如我们有个函数，从 `1` 数到 `1000000000`。
 
@@ -302,7 +336,11 @@ function count() {
   if (i == 1e9) {
     alert("Done in " + (Date.now() - start) + 'ms');
   } else {
+<<<<<<< HEAD
     setTimeout(count, 0); // 安排下一次任务 (**)
+=======
+    setTimeout(count); // schedule the new call (**)
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
   }
 
 }
@@ -318,7 +356,11 @@ count();
 2. 第二次做：`i=1000001..2000000` 的计数。
 3. ...等等，其中 `while` 语句检查 `i` 是否刚好能被 `1000000` 整除。
 
+<<<<<<< HEAD
 如果任务还没完成，在代码 `(*)` 处安排下一次调用。
+=======
+Then the next call is scheduled in `(**)` if we're not done yet.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `count` 函数调用的间隙足以让 JavaScript 引擎“缓口气了”，（浏览器）趁这段时间可以对用户的操作作出回应。
 
@@ -337,7 +379,11 @@ function count() {
 
   // 现在将调度放在开头
   if (i < 1e9 - 1e6) {
+<<<<<<< HEAD
     setTimeout(count, 0); // 安排下一次调用
+=======
+    setTimeout(count); // schedule the new call
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
   }
 
   do {
@@ -353,7 +399,11 @@ function count() {
 count();
 ```
 
+<<<<<<< HEAD
 因为知道 `count()` 不会只执行一次，所以这一次在计数开始前就安排好下一次计数任务。
+=======
+Now when we start to `count()` and see that we'll need to `count()` more, we schedule that immediately, before doing the job.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如果你自己跑一遍，会观察到这次的耗时要短上不少。
 
@@ -369,9 +419,15 @@ let times = [];
 setTimeout(function run() {
   times.push(Date.now() - start); // 保存上次调用的延时
 
+<<<<<<< HEAD
   if (start + 100 < Date.now()) alert(times); // 100 毫秒之后，显示延时信息
   else setTimeout(run, 0); // 没超过 100 毫秒则再进行调度
 }, 0);
+=======
+  if (start + 100 < Date.now()) alert(times); // show the delays after 100ms
+  else setTimeout(run); // else re-schedule
+});
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 // 示例输出：
 // 1,1,1,1,9,15,20,24,30,35,40,45,50,55,59,64,70,75,80,85,90,95,100
@@ -381,14 +437,24 @@ setTimeout(function run() {
 
 这个限制也是因为历史原因以及很多脚本都依赖于这个机制才得以存在至今。
 
+<<<<<<< HEAD
 服务端 JavaScript 就没这个限制了，而且除此之外还有其他办法来调度这种即时异步任务，例如 Node.JS 的 [process.nextTick](https://nodejs.org/api/process.html) 和 [setImmediate](https://nodejs.org/api/timers.html)。所以这个提醒也只是针对浏览器环境。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ````
 
 ### 给浏览器渲染的机会
 
+<<<<<<< HEAD
 行间脚本还有个益处，可以用来向用户展示进度条等。因为浏览器在所有脚本执行完后，才会开始“重绘（repainting）”过程。
 
 所以，如果运行一个非常耗时的函数，即便在这个函数中改变了文档内容，除非这个函数执行完，那么变化是不会立刻反映到页面上的。
+=======
+Another benefit of splitting heavy tasks for browser scripts is that we can show a progress bar or something to the user.
+
+Usually the browser does all "repainting" after the currently running code is complete. So if we do a single huge function that changes many elements, the changes are not painted out till it finishes.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 以下是一个示例：
 ```html run
@@ -400,8 +466,13 @@ setTimeout(function run() {
   function count() {
     for (let j = 0; j < 1e6; j++) {
       i++;
+<<<<<<< HEAD
       // 将当前 i 值放到 <div> 内
       // （innerHTML 在以后具体章节会讲到，这行代码看懂应该没问题）
+=======
+      // put the current i into the <div>
+      // (we'll talk about innerHTML in the specific chapter, it just writes into element here)
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
       progress.innerHTML = i;
     }
   }
@@ -429,7 +500,7 @@ setTimeout(function run() {
     } while (i % 1e3 != 0);
 
     if (i < 1e9) {
-      setTimeout(count, 0);
+      setTimeout(count);
     }
 
   }
@@ -442,6 +513,7 @@ setTimeout(function run() {
 
 ## 总结
 
+<<<<<<< HEAD
 - `setInterval(func, delay, ...args)` 和 `setTimeout(func, delay, ...args)` 可以让 `func` 定期或经历一段延时后一次性执行。
 - 要取消函数的执行需要调用 `clearInterval/clearTimeout`，只需将 `setInterval/setTimeout` 返回的值传入即可。
 - 嵌套 `setTimeout` 比 `setInterval` 用起来更加灵活，同时也能保证每一轮执行的最小时间间隔。
@@ -450,6 +522,16 @@ setTimeout(function run() {
 `setTimeout(...,0)` 的一些用法示例：
 - 将耗费 CPU 的任务分割成多块，这样脚本运行不会进入“挂起”状态。
 - 进程繁忙时也能让浏览器抽身做其它事情（例如绘制进度条）。
+=======
+- Methods `setInterval(func, delay, ...args)` and `setTimeout(func, delay, ...args)` allow to run the `func` regularly/once after `delay` milliseconds.
+- To cancel the execution, we should call `clearInterval/clearTimeout` with the value returned by `setInterval/setTimeout`.
+- Nested `setTimeout` calls is a more flexible alternative to `setInterval`. Also they can guarantee the minimal time *between* the executions.
+- Zero-timeout scheduling `setTimeout(func, 0)` (the same as `setTimeout(func)`) is used to schedule the call "as soon as possible, but after the current code is complete".
+
+Some use cases of `setTimeout(func)`:
+- To split CPU-hungry tasks into pieces, so that the script doesn't "hang"
+- To let the browser do something else while the process is going on (paint the progress bar).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 有一点需要注意，所有的调度方法都不能**保证**延时的准确性，所以在调度代码中，万不可依赖它。
 
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 060b2c293b..844c537882 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 4071849cd5..4fbf122c54 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 6c473a33cc..f59e157fb8 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 dd45e324f8..ed99391cf7 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 18919a1923..dcf07530ad 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,8 @@ for (let args of work.calls) {
 }
 ```
 
+<<<<<<< HEAD
 附：该装饰器有时用于单元测试，它的高级形式是 [Sinon.JS](http://sinonjs.org/) 库中的 `sinon.spy`。
+=======
+P.S. That decorator is sometimes useful for unit-testing. Its advanced form is `sinon.spy` in [Sinon.JS](http://sinonjs.org/) library.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 baf35bbe63..478185d6f0 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 @@
 解决方案：
 
-```js
+```js run demo
 function delay(f, ms) {
 
   return function() {
@@ -8,20 +8,29 @@ function delay(f, ms) {
   };
 
 }
+
+let f1000 = delay(alert, 1000);
+
+f1000("test"); // shows "test" after 1000ms
 ```
 
 注意这里是如何使用箭头函数的。我们知道，箭头函数没有自己的 `this` 和 `arguments`，所以 `f.apply(this, arguments)`从包装器中获取 `this` 和 `arguments`。
 
+<<<<<<< HEAD
 如果我们传递一个常规函数，`setTimeout` 将调用它且不带参数和 `this=window`（在浏览器中），所以我们需要编写更多代码来从包装器传递它们：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```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 337ac78928..ab809fb855 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,11 @@ function debounce(f, ms) {
 }
 ```
 
+<<<<<<< HEAD
 对 `debounce` 的调用返回一个包装器。可能有两种状态：
+=======
+A call to `debounce` returns a wrapper. There may be two states:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - `isCooldown = false` —— 准备好执行
 - `isCooldown = true` —— 等待时间结束
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 4f1b857441..a75fa089d8 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 f6543e17e2..27cba20e67 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
@@ -12,20 +12,35 @@ importance: 5
 
 **例如，我们想要跟踪鼠标移动。**
 
+<<<<<<< HEAD
 在浏览器中，我们可以设置一个函数，鼠标的每次微小的运动都执行，并在移动时获取指针位置。在活动鼠标使用期间，此功能通常非常频繁地运行，可以是每秒 100 次（每 10 毫秒）。
+=======
+In browser we can setup a function to run at every mouse movement and get the pointer location as it moves. During an active mouse usage, this function usually runs very frequently, can be something like 100 times per second (every 10 ms).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 **跟踪功能应更新网页上的一些信息。**
 
 更新函数 `update()` 太重了，无法在每次微小动作上执行。每 100 毫秒更频繁地制作一次也没有任何意义。 
 
+<<<<<<< HEAD
 因此我们将 `throttle(update, 100)` 指定为在每次鼠标移动时运行的函数，而不是原始的 `update()`。装饰器将经常调用，但 `update()` 最多每 100ms 调用一次。
+=======
+So we'll wrap it into the decorator: use `throttle(update, 100)` as the function to run on each mouse move instead of the original `update()`. The decorator will be called often, but `update()` will be called at maximum once per 100ms.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在视觉上，它看起来像这样：
 
+<<<<<<< HEAD
 1. 对于第一个鼠标移动，装饰变体将调用传递给 `update`。这很重要，用户会立即看到我们对他行动的反应。
 2. 然后当鼠标移动时，直到 “100ms” 没有任何反应。装饰的变体忽略了调用。
 3. 在 `100ms`  结束时 - 最后一个坐标发生了一次 `update`。
 4. 然后，最后，鼠标停在某处。装饰的变体等到 `100ms`到期，然后用最后一个坐标运行 `update`。因此，也许最重要的是处理最终的鼠标坐标。
+=======
+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` with last coordinates. So, perhaps the most important, the final mouse coordinates are processed.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 一个代码示例：
 
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 59cbfead92..1294028e12 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,11 @@ func.apply(context, args);   // 与使用 apply 相同
 
 所以，这些调用方式相互补充。我们期望有一个可迭代的 `call` 实现，我们也期望有一个类似数组，`apply` 的实现。
 
+<<<<<<< HEAD
 如果 `参数列表` 既可迭代又像数组一样，就像真正的数组一样，那么我们在技术上可以使用它们中的任何一个，但是 `apply` 可能会更快，因为它只是一个操作。大多数 JavaScript 引擎内部优化比一对 `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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `apply` 最重要的用途之一是将调用传递给另一个函数，如下所示：
 
@@ -453,7 +457,11 @@ let wrapper = function() {
 }
 ```
 
+<<<<<<< HEAD
 当我们从一个对象中获取一个方法并在另一个对象的上下文中“调用”它时，我们也看到了一个 **方法借用** 的例子。采用数组方法并将它们应用于参数是很常见的。另一种方法是使用静态参数对象，它是一个真正的数组。
+=======
+We also saw an example of *method borrowing* when we take a method from an object and `call` it in the context of another object. It is quite common to take array methods and apply them to `arguments`. The alternative is to use rest parameters object that is a real array.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 
 在 js 领域里有很多装饰器的使用方法 。快通过解决本章的任务来检查你掌握它们的程度吧。
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 171e27910d..d9541c7681 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 8d3b5434c2..17eef3f18c 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/5-question-use-bind/solution.md b/1-js/06-advanced-functions/10-bind/5-question-use-bind/solution.md
index 7417358078..8efa4cf422 100644
--- a/1-js/06-advanced-functions/10-bind/5-question-use-bind/solution.md
+++ b/1-js/06-advanced-functions/10-bind/5-question-use-bind/solution.md
@@ -38,6 +38,11 @@ askPassword(user.loginOk.bind(user), user.loginFail.bind(user));
 askPassword(() => user.loginOk(), () => user.loginFail());
 ```
 
+<<<<<<< HEAD
 通常情况下它也能正常运行，但是可能会在更复杂的场景下失效，例如在 asking 到运行 `() => user.loginOk()` 之间，`user` 可能会被重写。
 
+=======
+Usually that also works and looks good.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
+It's a bit less reliable though in more complex situations where `user` variable might change *after* `askPassword` is called, but *before* the visitor answers and calls `() => user.loginOk()`. 
diff --git a/1-js/06-advanced-functions/10-bind/5-question-use-bind/task.md b/1-js/06-advanced-functions/10-bind/5-question-use-bind/task.md
index c4759ee016..1cba526d8e 100644
--- a/1-js/06-advanced-functions/10-bind/5-question-use-bind/task.md
+++ b/1-js/06-advanced-functions/10-bind/5-question-use-bind/task.md
@@ -2,7 +2,11 @@ importance: 5
 
 ---
 
+<<<<<<< HEAD
 # 为什么 this 会丢失
+=======
+# Fix a function that loses "this"
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 下面代码中对 `askPassword()` 的调用将会检查密码然后基于结果调用 `user.loginOk/loginFail`。
 
@@ -34,5 +38,3 @@ let user = {
 askPassword(user.loginOk, user.loginFail);
 */!*
 ```
-
-
diff --git a/1-js/06-advanced-functions/10-bind/article.md b/1-js/06-advanced-functions/10-bind/article.md
index 991d9c487c..1eed2ad7cd 100644
--- a/1-js/06-advanced-functions/10-bind/article.md
+++ b/1-js/06-advanced-functions/10-bind/article.md
@@ -37,13 +37,21 @@ let f = user.sayHi;
 setTimeout(f, 1000); // 用户上下文丢失
 ```
 
+<<<<<<< HEAD
 浏览器中的方法 `setTimeout` 有些特殊：它为函数的调用设定了 `this=window`（对于 Node.JS，`this` 则会成为时间对象，但其实 this 到底变成什么并不十分重要）。所以对于 `this.firstName` 它其实试图获取的是 `window.firstName`，这个变量并不存在。在其他一些类似的情况下，通常 `this` 就会成为 `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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这个需求很典型——我们希望将一个对象的方法传递到别的地方（这里——是为了调度程序）然后调用。如何确保它将会在正确的上下文中被调用呢？
 
 ## 解决方案 1：包装层
 
+<<<<<<< HEAD
 最简单的解决方案就是使用一个包装函数：
+=======
+The simplest solution is to use a wrapping function:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let user = {
@@ -100,7 +108,7 @@ user = { sayHi() { alert("Another user in setTimeout!"); } };
 ```js
 // 稍后将会有更复杂的语法
 let boundFunc = func.bind(context);
-````
+```
 
 `func.bind(context)` 的结果是一个特殊的像函数一样的“外来对象”，它可以像函数一样被调用并且透明的将调用传递给 `func` 并设置 `this=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 9e1cf90055..fcfd049be2 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) {
 基于它，我们利用 `bind` 创造一个新函数 `double`：
 
 ```js run
+function mul(a, b) {
+  return a * b;
+}
+
 *!*
 let double = mul.bind(null, 2);
 */!*
@@ -46,6 +50,10 @@ alert( double(5) ); // = mul(2, 5) = 10
 以下代码中的 `triple` 函数对一个值做三倍运算：
 
 ```js run
+function mul(a, b) {
+  return a * b;
+}
+
 *!*
 let triple = mul.bind(null, 3);
 */!*
@@ -57,9 +65,15 @@ alert( triple(5) ); // = mul(3, 5) = 15
 
 为什么我们经常会创建一个偏函数？
 
+<<<<<<< HEAD
 这里，我们从中受益的是我们创建了一个独立的非匿名函数（`double`，`triple`）。我们可以使用它，而不需要每次都传入第一个参数，因为 `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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 举个例子，我们拥有函数 `send(from, to, text)`。然后，在 `user` 对象中，我们想要使用它的偏函数变体：`sendTo(to, text)`，该函数表明发送自一个当前的用户。
 
@@ -111,16 +125,24 @@ user.sayNow("Hello");
 
 有时候人们会把偏函数应用和另一个名为「柯里化」的东西混淆。那是另一个和函数有关的有趣的技术，我们在这里不得不提。
 
+<<<<<<< HEAD
 [Currying](https://en.wikipedia.org/wiki/Currying) 是一项将一个调用形式为 `f(a, b, c)` 的函数转化为调用形式为 `f(a)(b)(c)` 的技术。
 
 接下来让我们创建将两个函数连接起来的「柯里」函数。换句话说，它将 `f(a, b)` 转化为 `f(a)(b)`：
+=======
+[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.
+
+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)`
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```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 +178,17 @@ function curry(f) {
 
 ## 柯里化？目的是什么？
 
+<<<<<<< HEAD
 高级的柯里化同时允许函数正常调用和获取偏函数。为了理解这样的好处，我们确实需要一个好的现实例子。
 
 举个例子，我们有一个打印函数 `log(date, importance, message)` 格式化和输出信息。在真实的项目中，这样的函数有很多有用的特性，比如：通过网络传输或者筛选：
+=======
+To understand the benefits we definitely need a worthy real-life example.
+
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 function log(date, importance, message) {
@@ -202,15 +232,27 @@ let todayDebug = todayLog("DEBUG");
 todayDebug("message"); // [HH:mm] DEBUG message
 ```
 
+<<<<<<< HEAD
 那么：
 1. 柯里化之后我们没有丢失任何东西：`log` 依然可以被正常调用。
 2. 在很多情况下我们可以很方便生成偏函数。
+=======
+So:
+1. We didn't lose anything after currying: `log` is still callable normally.
+2. We were able to generate partial functions such as for today's logs.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 高级柯里化实现
 
+<<<<<<< HEAD
 由于你可能感兴趣，下面是我们可以使用的「高级」柯里化实现
+=======
+In case you'd like to get in details (not obligatory!), here's the "advanced" curry implementation that we could use above.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
-```js run
+It's pretty short:
+
+```js
 function curry(func) {
 
   return function curried(...args) {
@@ -224,13 +266,18 @@ function curry(func) {
   };
 
 }
+```
+
+Usage examples:
 
+```js
 function sum(a, b, c) {
   return a + b + c;
 }
 
 let curriedSum = curry(sum);
 
+<<<<<<< HEAD
 // 依然可以被正常调用
 alert( curriedSum(1, 2, 3) ); // 6
 
@@ -242,6 +289,14 @@ 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 easy to understand.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `curry(func)` 的结果是 `curried` 函数的封装，结果如下：
 
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 1d228b5c8a..0000000000
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 a4c195ad69..0000000000
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 a302343e2d..0000000000
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 4d3311998e..0000000000
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 19c1881a2f..0000000000
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 cd38624ab0..0000000000
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 0ea869d3c5..0000000000
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 194db77edd..0000000000
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 5bd2111474..0000000000
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 1e4ef6efbd..0000000000
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 c18e020525..0000000000
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 4d9e8ec094..0000000000
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 aed69c59e0..0000000000
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 2b11b2568b..0000000000
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 0dbc7b8fc4..0000000000
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 e38cb85bd9..0000000000
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 83258d0614..0000000000
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 d77cc8f4ec..0000000000
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 fa6a2943f6..0000000000
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 9368d7e502..0000000000
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 e7c6bdb212..0000000000
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 34c256bbfd..0000000000
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 d97d87d2c3..0000000000
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 76ce4c9ac5..0000000000
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 3eec740fbb..0000000000
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 ed28a388a0..0000000000
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 3254270f38..0000000000
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 f794d7b84a..0000000000
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 d3ef344852..0000000000
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 45cbb6baab..0000000000
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 0dbc7b8fc4..0000000000
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 e38cb85bd9..0000000000
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 83258d0614..0000000000
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 d77cc8f4ec..0000000000
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 fa6a2943f6..0000000000
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 9368d7e502..0000000000
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 e7c6bdb212..0000000000
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 34c256bbfd..0000000000
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 7c2e3f9c78..0000000000
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 fec1facb0b..0000000000
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 d97d87d2c3..0000000000
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 76ce4c9ac5..0000000000
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 3eec740fbb..0000000000
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 ed28a388a0..0000000000
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 d3ef344852..0000000000
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 45cbb6baab..0000000000
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/2-dictionary-tostring/solution.md b/1-js/07-object-oriented-programming/06-prototype-methods/2-dictionary-tostring/solution.md
deleted file mode 100644
index 9b1627e37a..0000000000
--- a/1-js/07-object-oriented-programming/06-prototype-methods/2-dictionary-tostring/solution.md
+++ /dev/null
@@ -1,29 +0,0 @@
-
-可以使用 `Object.keys` 列出所有可枚举键值，然后输出。
-
-为了使 `toString` 不可枚举，我们使用属性描述器来定义它。`Object.create` 语法允许我们为一个对象提供属性描述器作为第二参数。
-
-```js run
-*!*
-let dictionary = Object.create(null, {
-  toString: { // 定义 toString 方法
-    value() { // value 是一个函数
-      return Object.keys(this).join();
-    }
-  }
-});
-*/!*
-
-dictionary.apple = "Apple";
-dictionary.__proto__ = "test";
-
-// apple 和 __proto__ 在循环内
-for(let key in dictionary) {
-  alert(key); // "apple"，然后 "__proto__"
-}  
-
-// 通过 toString 得到逗号分隔的属性值
-alert(dictionary); // "apple,__proto__"
-```
-
-当我们使用描述器创建一个属性，它的标识默认是 `false`。因此在以上代码中，`dictonary.toString` 是不可枚举的。
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 ee42f6b98c..0000000000
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 1917c6631d..0000000000
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 7c2e3f9c78..0000000000
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 fec1facb0b..0000000000
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 3254270f38..0000000000
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 f794d7b84a..0000000000
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/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 7a193b79d0..0000000000
--- 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) min = '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 fdee13d01b..0000000000
--- 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 fdee13d01b..0000000000
--- 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/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 ad4a409322..0000000000
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 199ed3ee60..0000000000
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 70708c2848..0000000000
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 0db1301815..0000000000
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 e63d7d7844..0000000000
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 3d1be9ccef..0000000000
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 435ec5f89f..0000000000
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 5731da73a8..0000000000
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 fdee13d01b..0000000000
--- 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 b1a2625079..0000000000
--- 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) min = '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 fdee13d01b..0000000000
--- 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/1-rewrite-to-class/task.md b/1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/task.md
deleted file mode 100644
index 9e4b0b651a..0000000000
--- a/1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/task.md
+++ /dev/null
@@ -1,9 +0,0 @@
-importance: 5
-
----
-
-# 重写 class 声明
-
-按要求重写所有的 `Clock` 类声明方式，把所有类定义方式从 prototype 变为“现代”的 "class" 语法。
-
-P.S. clock 仅在 console 中打印，请打开 console 查看。
diff --git a/1-js/07-object-oriented-programming/09-class/animal-rabbit-extends.png b/1-js/07-object-oriented-programming/09-class/animal-rabbit-extends.png
deleted file mode 100644
index 2db88f3663..0000000000
Binary files a/1-js/07-object-oriented-programming/09-class/animal-rabbit-extends.png and /dev/null differ
diff --git a/1-js/07-object-oriented-programming/09-class/animal-rabbit-extends@2x.png b/1-js/07-object-oriented-programming/09-class/animal-rabbit-extends@2x.png
deleted file mode 100644
index 9539fe9ec6..0000000000
Binary files a/1-js/07-object-oriented-programming/09-class/animal-rabbit-extends@2x.png and /dev/null differ
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 5579e6bbdf..0000000000
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 5a85e6589d..0000000000
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 7ac1db7143..0000000000
--- 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 b48a2a0074..0000000000
--- 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/2-clock-class-extended/task.md b/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/task.md
deleted file mode 100644
index 933637247a..0000000000
--- a/1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/task.md
+++ /dev/null
@@ -1,13 +0,0 @@
-importance: 5
-
----
-
-# 继承 clock
-
-我们有一个 `Clock` 类。到目前为止，它每秒都会打印时间。
-
-从 `Clock` 继承并创建一个新的类 `ExtendedClock`，同时添加一个参数 `precision` —— 每次 "ticks" 之间间隔的毫秒数，默认是 `1000`（1秒）。
-
-- 你的代码在 `extended-clock.js` 文件里
-- 不要修改原来的 `clock.js`。只继承它。
-
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 d4ff37e561..0000000000
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 a54a9d2f86..0000000000
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-static.png b/1-js/07-object-oriented-programming/10-class-inheritance/animal-rabbit-static.png
deleted file mode 100644
index 998c823300..0000000000
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 98a80d38fa..0000000000
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 c5d712632f..0000000000
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 edc4e841ec..0000000000
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 70708c2848..0000000000
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 0db1301815..0000000000
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 542a0c9fa9..0000000000
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 21485062a8..0000000000
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 637d179398..0000000000
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 af7b443bcb..0000000000
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 85aa9a55f3..0000000000
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 fba7712207..0000000000
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 7cc655036f..0000000000
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 f53ecf68fd..0000000000
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/01-property-descriptors/article.md b/1-js/07-object-properties/01-property-descriptors/article.md
similarity index 83%
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 dbb11c7e9a..d3604c8227 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,13 @@
 
 我们知道，对象可以存储属性。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/01-property-descriptors/article.md
 到目前为止，属性对我们来说是一个简单的“键-值”对。但对象属性实际上是更复杂可变的东西。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/07-object-properties/01-property-descriptors/article.md
 
 ## 属性的标志
 
@@ -118,7 +124,11 @@ user.name = "Pete"; // 错误：不能设置只读属性'name'...
 */!*
 ```
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/01-property-descriptors/article.md
 现在没有人可以改变我们的用户名称，除非他用自己的 `defineProperty` 来覆盖我们的用户。
+=======
+Now no one can change the name of our user, unless they apply their own `defineProperty` to override ours.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/07-object-properties/01-property-descriptors/article.md
 
 以下是相同的操作，但针对的是属性不存在的情况：
 
@@ -191,7 +201,11 @@ alert(Object.keys(user)); // name
 
 一个不可配置的属性不能被 `defineProperty` 删除或修改。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/01-property-descriptors/article.md
 例如，`Math.PI` 是只读的、不可枚举和不可配置的：
+=======
+For instance, `Math.PI` is read-only, non-enumerable and non-configurable:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/07-object-properties/01-property-descriptors/article.md
 
 ```js run
 let descriptor = Object.getOwnPropertyDescriptor(Math, 'PI');
@@ -296,6 +310,7 @@ for (let key in user) {
 还有一些限制访问**整个**对象的方法：
 
 [Object.preventExtensions(obj)](mdn:js/Object/preventExtensions)
+<<<<<<< HEAD:1-js/07-object-oriented-programming/01-property-descriptors/article.md
 : 禁止向对象添加属性。
 
 [Object.seal(obj)](mdn:js/Object/seal)
@@ -305,6 +320,16 @@ for (let key in user) {
 : 禁止添加/删除/更改属性，为所有现有属性设置 `configurable: false, writable: false`。
 
 还有对他们的测试：
+=======
+: Forbids the addition of new properties to the object.
+
+[Object.seal(obj)](mdn:js/Object/seal)
+: Forbids adding/removing of properties. Sets `configurable: false` for all existing properties.
+
+[Object.freeze(obj)](mdn:js/Object/freeze)
+: Forbids adding/removing/changing of properties. Sets `configurable: false, writable: false` for all existing properties.
+And also there are tests for them:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/07-object-properties/01-property-descriptors/article.md
 
 [Object.isExtensible(obj)](mdn:js/Object/isExtensible)
 : 如果添加属性被禁止，则返回 `false`，否则返回 `true`。
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 91%
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 f43cc586fa..0cb9808bd1 100644
--- a/1-js/07-object-oriented-programming/02-property-accessors/article.md
+++ b/1-js/07-object-properties/02-property-accessors/article.md
@@ -84,12 +84,22 @@ alert(user.surname); // Cooper
 
 现在我们有一个“虚拟”属性。它是可读写的，但实际上并不存在。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/02-property-accessors/article.md
 ```smart header="访问器属性只能访问 get/set"
 属性可以是“数据属性”或“访问器属性”，但不能同时属于两者。
 
 一旦使用 `get prop()` 或 `set prop()` 定义了一个属性，它就是一个访问器属性。所以必须有一个getter来读取它，如果我们对它赋值，它必须是一个 setter。
 
 有时候只有一个 setter 或者只有一个 getter 是正常的。但在这种情况下，该属性将不可读或可写。
+=======
+```smart header="Accessor properties are only accessible with get/set"
+Once a property is defined with `get prop()` or `set prop()`, it's an accessor property, not a data property any more.
+
+- If there's a getter -- we can read `object.prop`, otherwise we can't.
+- If there's a setter -- we can set `object.prop=...`, otherwise we can't.
+
+And in either case we can't `delete` an accessor property.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/07-object-properties/02-property-accessors/article.md
 ```
 
 
diff --git a/1-js/07-object-properties/index.md b/1-js/07-object-properties/index.md
new file mode 100644
index 0000000000..67fcccaffc
--- /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 6a91b63295..0000000000
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 8bf9680fd6..0000000000
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 85%
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
index a46bda6e14..78350f31db 100644
--- 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
@@ -44,7 +44,11 @@ alert( lazy.stomach ); // <nothing>
 
 现在，所有的都在正常运行，因为 `this.stomach=` 不会在 `stomach` 中执行查找。该值会被直接写入 `this` 对象。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/03-prototype-inheritance/4-hamster-proto/solution.md
 此外，我们还可以通过确保每只仓鼠都有自己的胃来完全回避这个问题：
+=======
+Also we can totally evade the problem by making sure that each hamster has their own stomach:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/solution.md
 
 ```js run
 let hamster = {
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 50%
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 4f70358535..b9d54ce587 100644
--- a/1-js/07-object-oriented-programming/03-prototype-inheritance/article.md
+++ b/1-js/08-prototypes/01-prototype-inheritance/article.md
@@ -12,7 +12,11 @@
 
 ![prototype](object-prototype-empty.png)
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/03-prototype-inheritance/article.md
 `[[Prototype]]` 有一个“神奇”的意义。当我们想要从 `object` 中读取一个属性时，它就丢失了。JavaScript 会自动从原型中获取它。在编程中，这样的事情称为“原型继承”。许多很酷的语言特性和编程技巧都是基于它的。
+=======
+The prototype is a little bit "magical". When we want to read a property from `object`, and it's missing, JavaScript automatically takes it from the prototype. In programming, such thing is called "prototypal inheritance". Many cool language features and programming techniques are based on it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/01-prototype-inheritance/article.md
 
 属性 `[[Prototype]]` 是内部的而且隐藏的，但是设置它的方法却有很多种。
 
@@ -31,7 +35,17 @@ rabbit.__proto__ = animal;
 */!*
 ```
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/03-prototype-inheritance/article.md
 请注意 `__proto__` 与 `[[Prototype]]` **不一样**。这是一个 getter/setter。我们之后会讨论如何设置它，但是现在 `__proto__` 工作的很好。
+=======
+```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.
+```
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/01-prototype-inheritance/article.md
 
 如果我们在 `rabbit` 中查找一个属性，而且它丢失了，JavaScript 会自动从 `animal` 中获取它。
 
@@ -62,7 +76,11 @@ alert( rabbit.jumps ); // true
 
 ![](proto-animal-rabbit.png)
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/03-prototype-inheritance/article.md
 我们可以说 "`animal` 是 `rabbit`" 的原型或者说 "`rabbit` 的原型继承自 `animal`"。
+=======
+Here we can say that "`animal` is the prototype of `rabbit`" or "`rabbit` prototypically inherits from `animal`".
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/01-prototype-inheritance/article.md
 
 因此如果 `animal` 有许多有用的属性和方法，那么它们在 `rabbit` 中会自动变为可用的。这种属性行为称为“继承”。
 
@@ -106,13 +124,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
@@ -123,16 +145,29 @@ alert(longEar.jumps); // true (from rabbit)
 
 实际上只有两个限制：
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/03-prototype-inheritance/article.md
 1. 引用不能形成闭环。如果我们试图在一个闭环中分配 `__proto__`，JavaScript 会抛出异常。
 2. `__proto__` 的值可以是对象，也可以是 `null`。所有其他的值（例如原语）都会被忽略。
+=======
+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`, other types (like primitives) are ignored.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/01-prototype-inheritance/article.md
 
 这也可能是显而易见的，即：只能有一个 `[[Prototype]]`。对象不能继承自其他两个对象。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/03-prototype-inheritance/article.md
 ## 读写规则
+=======
+## Writing doesn't use prototype
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/01-prototype-inheritance/article.md
 
 原型仅用于读取属性。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/03-prototype-inheritance/article.md
 对于数据属性（不是 getters/setters）写/删除操作直接在对象上进行操作。
+=======
+Write/delete operations work directly with the object.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/01-prototype-inheritance/article.md
 
 在以下示例中，我们将 `walk` 方法分配给 `rabbit`：
 
@@ -146,7 +181,7 @@ let animal = {
 
 let rabbit = {
   __proto__: animal
-}
+};
 
 *!*
 rabbit.walk = function() {
@@ -161,9 +196,15 @@ rabbit.walk(); // Rabbit! Bounce-bounce!
 
 ![](proto-animal-rabbit-walk-2.png)
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/03-prototype-inheritance/article.md
 对于 getters/setters —— 如果我们读写一个属性，就会在原型中查找并调用它们。
 
 例如，在以下代码中检查出 `admin.fullName` 属性：
+=======
+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 that reason `admin.fullName` works correctly in the code below:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/01-prototype-inheritance/article.md
 
 ```js run
 let user = {
@@ -194,15 +235,25 @@ admin.fullName = "Alice Cooper"; // (**)
 
 ## "this" 的值
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/03-prototype-inheritance/article.md
 在上面的例子中可能会出现一个有趣的现象：在 `set fullName(value)` 中 `this` 的值是什么？属性 `this.name` 和 `this.surname` 写在哪里： `user` 还是 `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`?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/01-prototype-inheritance/article.md
 
 答案很简单：`this` 根本不受原型的影响。
 
 **无论在哪里找到方法：在对象或者原型中。调用方法时，`this` 始终是点之前的对象。**
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/03-prototype-inheritance/article.md
 因此，实际上 setter 使用 `admin` 作为 `this`，而不是 `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 inherited objects can run its methods, and they will modify the state of these objects, not the big one.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/01-prototype-inheritance/article.md
 
 例如，这里的 `animal` 代表“方法存储”，而且 `rabbit` 在使用它。
 
@@ -241,6 +292,7 @@ alert(animal.isSleeping); // undefined (no such property in the prototype)
 
 因此，方法是共享的，但对象状态不是。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/03-prototype-inheritance/article.md
 ## 总结
 
 - JavaScript 中，所有的对象都有一个隐藏的 `[[Prototype]]` 属性，它可以是另一个对象或者 `null`。
@@ -248,3 +300,82 @@ alert(animal.isSleeping); // undefined (no such property in the prototype)
 - `[[Prototype]]` 引用的对象称为“原型”。
 - 如果我们想要读取 `obj` 属性或者调用一个方法，而且它不存在，那么 JavaScript 就会尝试在原型中查找它。写/删除直接在对象上进行操作，它们不使用原型（除非属性实际上是一个 setter）。
 - 如果我们调用 `obj.method()`，而且 `method` 是从原型中获取的，`this` 仍然会引用 `obj`。因此方法重视与当前对象一起工作，即使它们是继承的。
+=======
+## for..in loop
+
+The `for..in` loops over inherited properties too.
+
+For instance:
+
+```js run
+let animal = {
+  eats: true
+};
+
+let rabbit = {
+  jumps: true,
+  __proto__: animal
+};
+
+*!*
+// Object.keys only return own keys
+alert(Object.keys(rabbit)); // jumps
+*/!*
+
+*!*
+// for..in loops over both own and inherited keys
+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);
+
+  if (isOwn) {
+    alert(`Our: ${prop}`); // Our: jumps
+  } else {
+    alert(`Inherited: ${prop}`); // Inherited: eats
+  }
+}
+```
+
+Here we have the following inheritance chain: `rabbit` inherits from `animal`, that inherits from `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? We did not define it. 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, like `eats` and `jumps`, if it lists all inherited properties.
+
+The answer is simple: it's not enumerable. Just like all other properties of `Object.prototype`, it has `enumerable:false` flag. That's why they are not listed.
+
+```smart header="All other iteration methods ignore inherited properties"
+All other key/value-getting methods, such as `Object.keys`, `Object.values` and so on ignore inherited properties.
+
+They only operate on the object itself. Properties from the prototype are taken into account.
+```
+
+## 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 (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 for act directly on the object, they don't use the prototype (assuming it's a data property, not is 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.
+- The `for..in` loop iterates over both own and inherited properties. All other key/value-getting methods only operate on the object itself.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/01-prototype-inheritance/article.md
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 0000000000..3ecff3fddf
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 0000000000..f80e61e680
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 0000000000..48e02ad18b
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 0000000000..1a04db885e
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 0000000000..22b867fc88
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 0000000000..8d9f9f1ae9
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 0000000000..bc76d64baa
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 0000000000..725a4c150b
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 0000000000..29fc6d5039
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 0000000000..724d6111b6
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 0000000000..d50327f0e7
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 0000000000..0506b92b69
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 0000000000..c37d007804
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 0000000000..8c3f546ebc
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/proto-user-admin@2x.png differ
diff --git a/1-js/08-prototypes/01-prototype-inheritance/rabbit-animal-object.png b/1-js/08-prototypes/01-prototype-inheritance/rabbit-animal-object.png
new file mode 100644
index 0000000000..3924233ddd
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/rabbit-animal-object.png differ
diff --git a/1-js/08-prototypes/01-prototype-inheritance/rabbit-animal-object@2x.png b/1-js/08-prototypes/01-prototype-inheritance/rabbit-animal-object@2x.png
new file mode 100644
index 0000000000..5350a19356
Binary files /dev/null and b/1-js/08-prototypes/01-prototype-inheritance/rabbit-animal-object@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 67%
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 27a87a7239..f29fc7adf0 100644
--- a/1-js/07-object-oriented-programming/04-function-prototype/article.md
+++ b/1-js/08-prototypes/02-function-prototype/article.md
@@ -1,5 +1,6 @@
 # 函数原型
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/04-function-prototype/article.md
 在现代 JavaScript 中，我们可以使用 `__proto__` 设置一个原型，如前一篇文章中所述。但事情并非如此。
 
 JavaScript 从一开始就有了原型继承。这是该语言的核心特征之一。
@@ -13,6 +14,17 @@ JavaScript 从一开始就有了原型继承。这是该语言的核心特征之
 当用 `new F()` 创建一个新对象时，该对象的 `[[Prototype]]` 被设置为 `F.prototype`。
 
 换句话说，如果 `F` 有一个 `prototype` 属性，该属性具有一个对象类型的值，那么 `new` 运算符就会使用它为新对象设置 `[[Prototype]]`。
+=======
+Remember, new objects can be created with a constructor function, like `new F()`.
+
+If `F.prototype` is an object, then `new` operator uses it to set `[[Prototype]]` for the new object.
+
+```smart
+JavaScript had prototypal inheritance from the beginning. It was one of the core features of the language.
+
+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.
+```
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/02-function-prototype/article.md
 
 请注意，`F.prototype` 意味着在 `F` 上有一个名为 `"prototype"` 的常规属性。这听起来与“原型”这个术语很相似，但在这里我们的意思是值有这个名字的常规属性。
 
@@ -42,8 +54,17 @@ alert( rabbit.eats ); // true
 
 ![](proto-constructor-animal-rabbit.png)
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/04-function-prototype/article.md
 在图片上，`"prototype"` 是一个水平箭头，它是一个常规属性，`[[Prototype]]` 是垂直的，意味着是继承自 `animal` 的 `rabbit`。
+=======
+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".
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/02-function-prototype/article.md
 
+If, after the creation, `F.prototype` property changes (`F.prototype = <another object>`), then new objects created by `new F` will have another object as `[[Prototype]]`, but already existing objects keep the old one.
+```
 
 ##  默认的函数原型，构造函数属性
 
@@ -139,7 +160,11 @@ Rabbit.prototype.jumps = true
 // the default Rabbit.prototype.constructor is preserved
 ```
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/04-function-prototype/article.md
 或者，也可以手动重新创建 `constructor` 属性：
+=======
+Or, alternatively, recreate the `constructor` property manually:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/02-function-prototype/article.md
 
 ```js
 Rabbit.prototype = {
@@ -159,9 +184,15 @@ Rabbit.prototype = {
 
 一切都很简单，只需要几条笔记就能说清楚：
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/04-function-prototype/article.md
 - `F.prototype` 属性与 `[[Prototype]]` 不同。`F.prototype` 唯一的作用是：当 `new F()` 被调用时，它设置新对象的 `[[Prototype]]`。
 - `F.prototype` 的值应该是一个对象或 null：其他值将不起作用。
 - `"prototype"` 属性在设置为构造函数时仅具有这种特殊效果，并且用 `new` 调用。
+=======
+- The `F.prototype` property is not the same as `[[Prototype]]`. The only thing `F.prototype` does: it sets `[[Prototype]]` of new objects when `new F()` is called.
+- The value of `F.prototype` should be either an object or null: other values won't work.
+-  The `"prototype"` property only has such a special effect when set on a constructor function, and invoked with `new`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/02-function-prototype/article.md
 
 在常规对象上，`prototype` 没什么特别的：
 ```js
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 0000000000..6ab9c6934a
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 0000000000..3beb0a5733
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 0000000000..c47938674b
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 0000000000..293c88bf93
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 0000000000..c4658a9291
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 0000000000..79445fac90
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 0000000000..a69cad4a1b
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 0000000000..9d661ac17e
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 0000000000..820ffcc736
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 0000000000..1eb7e8749d
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 0000000000..4b381460a5
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 0000000000..c6e6ab5f60
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 0000000000..3924233ddd
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 0000000000..5350a19356
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 0000000000..8f3519a747
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 0000000000..07acb8f4a9
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 55%
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 246f2453b4..2b5a677cfd 100644
--- a/1-js/07-object-oriented-programming/05-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -15,6 +15,7 @@ alert( obj ); // "[object Object]" ?
 
 生成字符串 `"[object Object]"` 的代码在哪里？那就是内置的一个 `toString` 方法，但是它在哪里呢？`obj` 是空的！
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/05-native-prototypes/article.md
 ...然而简短的表达式 `obj = {}` 和 `obj = new Object()` 是一个意思，其中 `Object` 是一个内置的对象构造函数。并且这个方法有一个 `Object.prototype` 属性，这个属性引用了一个庞大的对象，这个庞大的对象有 `toString` 方法和其他的一些方法。
 
 就像这样（所有的这些都是内置的）：
@@ -26,6 +27,19 @@ alert( obj ); // "[object Object]" ?
 ![](object-prototype-1.png)
 
 之后当 `obj.toString()` 被调用时，这个方法是在 `Object.prototype` 中被取到的。
+=======
+...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.
+
+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` according to the rule that we discussed in the previous chapter:
+
+![](object-prototype-1.png)
+
+So then when `obj.toString()` is called the method is taken from `Object.prototype`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/03-native-prototypes/article.md
 
 我们可以这样验证它：
 
@@ -48,7 +62,11 @@ alert(Object.prototype.__proto__); // null
 
 例如，当我们创建一个数组 `[1, 2, 3]`，内部使用默认的 `new Array()` 构造函数。因此这个数组数据被写进了这个新的数组对象，并且 `Array.prototype` 成为这个数组对象的原型且为数组对象提供数组的操作方法。这样内存的存储效率是很高的。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/05-native-prototypes/article.md
 按照规范，所有的内置原型顶端都是 `Object.prototype`。有些时候人们说“一切都从对象上继承而来”。
+=======
+By specification, all of the built-in prototypes have `Object.prototype` on the top. Sometimes people say that "everything inherits from objects".
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/03-native-prototypes/article.md
 
 下面是完整的示意图（3 个内置对象）：
 
@@ -82,11 +100,19 @@ alert(arr); // 1,2,3 <-- the result of Array.prototype.toString
 ![](native-prototypes-array-tostring.png)
 
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/05-native-prototypes/article.md
 像 Chrome 开发者控制台这样的浏览器内置工具也显示继承关系的（可能需要对内置对象使用 `console.dir`）：
 
 ![](console_dir_array.png)
 
 其他内置对象以同样的方式运行。即使是函数。它们是内置构造函数 `Function` 创建出来的对象，并且他们的方法：`call/apply` 和其他方法都来自 `Function.prototype`。函数也有自己的 `toString` 方法。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/03-native-prototypes/article.md
 
 ```js run
 function f() {}
@@ -119,11 +145,27 @@ String.prototype.show = function() {
 "BOOM!".show(); // BOOM!
 ```
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/05-native-prototypes/article.md
 在开发的过程中我们可能会想在内置对象上创建一个我们想要的方法。把他们添加到原生对象的原型中可能看起来不错，但那样通常来说是个坏主意。
 
 原型是全局的，所以很容易造成冲突。如果有两个代码段都添加了 `String.prototype.show` 方法，那么其中一个将覆盖另外一个。
 
 在现代编程中，只有一种情况下修改原生原型是被允许的。那就是在做 polyfills （译者注：兼容）的时候。换句话说，如果有一个 JavaScript 规范还没有被我们的 JavaScript 引擎支持（或者我们希望被支持的那些规范），那么需要手动实现这些规范并且把这些手动实现填充到内置对象的原型上。
+=======
+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.
+
+```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.
+
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/03-native-prototypes/article.md
 
 例如：
 
@@ -134,9 +176,15 @@ if (!String.prototype.repeat) { //假设没有这个方法
   String.prototype.repeat = function(n) {
     //重复字符串 n 次
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/05-native-prototypes/article.md
     //实际上代码是比这个更复杂的，
     //当 "n" 的值为负数的时候抛出异常
     //完整的算法在规范中
+=======
+    // 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
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/03-native-prototypes/article.md
     return new Array(n + 1).join(this);
   };
 }
@@ -144,37 +192,72 @@ if (!String.prototype.repeat) { //假设没有这个方法
 alert( "La".repeat(3) ); // LaLaLa
 ```
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/05-native-prototypes/article.md
 ## 从原型中借用
 
 在 <info:call-apply-decorators#method-borrowing> 章节中我们讨论的方法借用：
+=======
+
+## Borrowing from prototypes
+
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/03-native-prototypes/article.md
 
 ```js run
-function showArgs() {
+let obj = {
+  0: "Hello",
+  1: "world!",
+  length: 2,
+};
+
 *!*
+<<<<<<< HEAD:1-js/07-object-oriented-programming/05-native-prototypes/article.md
   // 从数组借用 join 方法并在 arguments 的上下文中调用
   alert( [].join.call(arguments, " - ") );
+=======
+obj.join = Array.prototype.join;
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/03-native-prototypes/article.md
 */!*
-}
 
-showArgs("John", "Pete", "Alice"); // John - Pete - Alice
+alert( obj.join(',') ); // Hello,world!
 ```
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/05-native-prototypes/article.md
 因为 `join` 方法在 `Array.prototype` 对象上，我们可以直接调用它并且重写上面的代码：
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/03-native-prototypes/article.md
 
-```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.
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/05-native-prototypes/article.md
 这样是更有效率的，因为它避免了一个额外数组对象 `[]` 的创建。另一方面，这样做，需要更长的时间来编写。
+=======
+Borrowing methods is flexible, it allows to mix functionality from different objects if needed.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/03-native-prototypes/article.md
 
 ## 总结
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/05-native-prototypes/article.md
 - 所有的内置对象都遵循一样的模式：
     - 方法都存储在原型对象上（`Array.prototype`、`Object.prototype`、`Date.prototype` 等）。
     - 对象本身只存储数据（数组元素、对象属性、日期）。
 - 基本数据类型同样在包装对象的原型上存储方法：`Number.prototype`、`String.prototype` 和 `Boolean.prototype`。只有 `undefined` 和 `null` 没有包装对象。
 - 内置对象的原型可以被修改或者被新的方法填充。但是这样做是不被推荐的。只有当添加一个还没有被 JavaScript 引擎支持的新方法的时候才可能允许这样做。
+=======
+- 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`. 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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/03-native-prototypes/article.md
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 0000000000..6ab9c6934a
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 0000000000..3beb0a5733
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 0000000000..c47938674b
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 0000000000..293c88bf93
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 0000000000..c4658a9291
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 0000000000..79445fac90
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 0000000000..a69cad4a1b
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 0000000000..9d661ac17e
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 0000000000..792c4f4237
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 0000000000..d97efa8849
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 0000000000..820ffcc736
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 0000000000..1eb7e8749d
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 0000000000..4b381460a5
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 0000000000..c6e6ab5f60
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 0000000000..8f3519a747
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 0000000000..07acb8f4a9
Binary files /dev/null and b/1-js/08-prototypes/03-native-prototypes/rabbit-prototype-constructor@2x.png differ
diff --git a/1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/solution.md b/1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/solution.md
new file mode 100644
index 0000000000..8278f8f4d2
--- /dev/null
+++ b/1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/solution.md
@@ -0,0 +1,39 @@
+
+可以使用 `Object.keys` 列出所有可枚举键值，然后输出。
+
+<<<<<<< HEAD:1-js/07-object-oriented-programming/06-prototype-methods/2-dictionary-tostring/solution.md
+为了使 `toString` 不可枚举，我们使用属性描述器来定义它。`Object.create` 语法允许我们为一个对象提供属性描述器作为第二参数。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/solution.md
+
+```js run
+*!*
+let dictionary = Object.create(null, {
+  toString: { // 定义 toString 方法
+    value() { // value 是一个函数
+      return Object.keys(this).join();
+    }
+  }
+});
+*/!*
+
+dictionary.apple = "Apple";
+dictionary.__proto__ = "test";
+
+// apple 和 __proto__ 在循环内
+for(let key in dictionary) {
+  alert(key); // "apple"，然后 "__proto__"
+}  
+
+// 通过 toString 得到逗号分隔的属性值
+alert(dictionary); // "apple,__proto__"
+```
+
+<<<<<<< HEAD:1-js/07-object-oriented-programming/06-prototype-methods/2-dictionary-tostring/solution.md
+当我们使用描述器创建一个属性，它的标识默认是 `false`。因此在以上代码中，`dictonary.toString` 是不可枚举的。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/solution.md
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 62%
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 796952dfa9..1150b2e665 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,11 @@ importance: 5
 
 ---
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/06-prototype-methods/3-compare-calls/task.md
 # 调用方式的差异
+=======
+# The difference between calls
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/04-prototype-methods/3-compare-calls/task.md
 
 让我们创建一个新的 `rabbit` 对象：
 
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 62%
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 e424e5f1d8..a6a2ca285e 100644
--- a/1-js/07-object-oriented-programming/06-prototype-methods/article.md
+++ b/1-js/08-prototypes/04-prototype-methods/article.md
@@ -1,15 +1,31 @@
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/06-prototype-methods/article.md
 # 原型方法
 
 本章节我们会讨论原型（prototype）的附加方法。
 
 获取/设置原型的方式有很多，我们已知的有：
+=======
+# Prototype methods, objects without __proto__
+
+In the first chapter of this section, we mentioned that there are modern methods to setup a prototype.
+
+The `__proto__` is considered outdated and somewhat deprecated (in browser-only part of the JavaScript standard).
+
+The modern methods are:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/04-prototype-methods/article.md
 
 - [Object.create(proto[, descriptors])](mdn:js/Object/create) —— 利用 `proto` 作为 `[[Prototype]]` 和可选的属性描述来创建一个空对象。
 - [Object.getPrototypeOf(obj)](mdn:js/Object/getPrototypeOf) —— 返回 `obj` 对象的 `[[Prototype]]`。
 - [Object.setPrototypeOf(obj, proto)](mdn:js/Object/setPrototypeOf) —— 将 `obj` 对象的 `[[Prototype]]` 设置为 `proto`。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/06-prototype-methods/article.md
 举个例子：
+=======
+These should be used instead of `__proto__`.
+
+For instance:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/04-prototype-methods/article.md
 
 ```js run
 let animal = {
@@ -66,13 +82,29 @@ let clone = Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescr
 
 这里有历史遗留问题。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/06-prototype-methods/article.md
 - 在上古时代 `prototype` 作为一个构造函数的属性来运行。
 - 之后在 2012 年： `Object.create` 出现在标准中。它允许利用给定的原型来创建对象，但是不能 get/set 原型。因此许多浏览器厂商实现了非标准属性  `__proto__`，允许任何时候 get/set 原型。
 - 之后在 2015 年： `Object.setPrototypeOf` 和 `Object.getPrototypeOf` 被加入到标准中。 `__proto__` 在几乎所有地方都得到实现，因此它成了标准以外的替代方案 B，在非浏览器环境下，它的支持性是不确定的，可选的。
+=======
+- The `"prototype"` property of a constructor function works since very ancient times.
+- Later in the year 2012: `Object.create` appeared in the standard. It allowed to create objects with the given prototype, but did not allow to get/set it. So browsers implemented non-standard `__proto__` accessor that allowed to get/set a prototype at any time.
+- Later in the year 2015: `Object.setPrototypeOf` and `Object.getPrototypeOf` were added to the standard, to perform the same functionality as `__proto__`. As `__proto__` was de-facto implemented everywhere, it was kind-of deprecated and made its way to the Annex B of the standard, that is optional for non-browser environments.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/04-prototype-methods/article.md
 
 目前为止，我们拥有了所有这些方式。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/06-prototype-methods/article.md
 从技术上来讲，我们可以在任何时候 get/set `[[Prototype]]`。但是通常我们只在创建对象的时候设置它一次，自那之后不再修改：`rabbit` 继承自 `animal`，之后不再改变。对此 JavaScript 引擎做了高度的优化。运行中利用 `Object.setPrototypeOf` 或者 `obj.__proto__=` 来更改 prototype 是一个非常缓慢的操作。但是，这是可行的。
+=======
+Why was `__proto__` replaced by the functions `getPrototypeOf/setPrototypeOf`? 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.
+```
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/04-prototype-methods/article.md
 
 ## 「极简」对象
 
@@ -95,11 +127,21 @@ alert(obj[key]); // [object Object]，而不是 "some value"！
 
 我们不应该感到惊讶。`__proto__` 属性很特别：它必须是对象或者 `null` 值，字符串不能成为 prototype。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/06-prototype-methods/article.md
 但是我们并不想实现这样的行为，对吗？我们想要存储键值对，然而键名为 `"__proto__"` 没有被正确存储。所以这是一个错误。在这里，结果并没有很严重。但是在其他用例中，prototype 可能被改变，因此可能导致完全意想不到的结果。
+=======
+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, we may be assigning object values, then the prototype may indeed be changed. As the result, the execution will go wrong in totally unexpected ways.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/04-prototype-methods/article.md
 
 最可怕的是 —— 通常开发者完全不会考虑到这一点。这让类似的 bug 很难被发现，甚至使得它们容易遭到攻击，特别是当 JavaScript 被用在服务端的时候。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/06-prototype-methods/article.md
 这样的情况只出现在 `__proto__` 上，所有其他的属性都是正常被「赋值」。
+=======
+Unexpected things also may happen when accessing `toString` property -- that's a function by default, and other built-in properties.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/04-prototype-methods/article.md
 
 怎么样避免这个错误呢？
 
@@ -111,9 +153,15 @@ alert(obj[key]); // [object Object]，而不是 "some value"！
 
 ![](object-prototype-2.png)
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/06-prototype-methods/article.md
 因此，如果 `obj.__proto__` 被读取或者赋值，那么对应的 getter/setter 从它的原型被调用，它会获取/设置 `[[Prototype]]`。
 
 就像开头所说：`__proto__` 是访问 `[[Prototype]]` 的方式，而不是 `[[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 of this tutorial section: `__proto__` is a way to access `[[Prototype]]`, it is not `[[Prototype]]` itself.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/04-prototype-methods/article.md
 
 现在，我们想要使用一个对象作为关联数组，我们可以用一个小技巧：
 
@@ -153,12 +201,13 @@ alert(obj); // Error （没有 toString 方法）
 
 ```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
 ```
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/06-prototype-methods/article.md
 ## 获取所有属性
 
 获取一个对象的键/值有很多种方法。
@@ -209,22 +258,26 @@ for(let prop in rabbit) alert(prop); // jumps，然后 eats
 如果我们想要区分继承属性，有一个内置方法 [obj.hasOwnProperty(key)](mdn:js/Object/hasOwnProperty)：如果 `obj` 有名为 `key` 的自身属性（而非继承），返回值为 `true`。
 
 因此我们可以找出继承属性（或者对它们进行一些操作）：
+=======
+## Summary
 
-```js run
-let animal = {
-  eats: true
-};
+Modern methods to setup and directly access the prototype are:
 
-let rabbit = {
-  jumps: true,
-  __proto__: animal
-};
+- [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).
+
+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.
 
-for(let prop in rabbit) {
-  let isOwn = rabbit.hasOwnProperty(prop);
-  alert(`${prop}: ${isOwn}`); // jumps:true, then eats:false
-}
+So we can either use `Object.create(null)` to create a "very plain" object without `__proto__`, or stick to `Map` objects for that.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/04-prototype-methods/article.md
+
+Also, `Object.create` provides an easy way to shallow-copy an object with all descriptors:
+
+```js
+let clone = Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
 ```
+<<<<<<< HEAD:1-js/07-object-oriented-programming/06-prototype-methods/article.md
 这个例子中我们有以下继承链：`rabbit`，然后 `animal`，然后 `Object.prototype` （因为 `animal` 是个字面量对象 `{...}`，因此默认是这样），然后最终到达 `null`：
 
 ![](rabbit-animal-object.png)
@@ -245,6 +298,15 @@ for(let prop in rabbit) {
 - [Object.getOwnPropertyNames(obj)](mdn:js/Object/getOwnPropertyNames) —— 返回包含所有自身字符串属性名称的数组。
 - [Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys) —— 返回包含所有自身属性名称的数组。
 - [obj.hasOwnProperty(key)](mdn:js/Object/hasOwnProperty)：如果 `obj` 拥有名为 `key` 的自身属性（非继承得来），返回 `true`。
+=======
+
+
+- [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 keys.
+- [Object.getOwnPropertyNames(obj)](mdn:js/Object/getOwnPropertyNames) -- returns an array of all own string keys.
+- [Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys) -- returns an array of all own keys.
+- [obj.hasOwnProperty(key)](mdn:js/Object/hasOwnProperty): it returns `true` if `obj` has its own (not inherited) keytt named `key`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/08-prototypes/04-prototype-methods/article.md
 
 同时我们还明确了 `__proto__` 是 `[[Prototype]]` 的 getter/setter，位置在 `Object.prototype`，和其他方法相同。
 
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 0000000000..343435af6c
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 0000000000..86b8a678e1
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 0000000000..792c4f4237
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 0000000000..d97efa8849
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/index.md b/1-js/08-prototypes/index.md
new file mode 100644
index 0000000000..8554a0e30b
--- /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 59%
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 c710b9da9b..0b31cf334e 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,21 +1,21 @@
 class Clock {
   constructor({ template }) {
-    this._template = template;
+    this.template = template;
   }
 
-  _render() {
+  render() {
     let date = new Date();
 
     let hours = date.getHours();
     if (hours < 10) hours = '0' + hours;
 
     let mins = date.getMinutes();
-    if (mins < 10) min = '0' + mins;
+    if (mins < 10) mins = '0' + mins;
 
     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 85%
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 26081a35a1..f1749c8ba5 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
@@ -9,7 +9,7 @@ function Clock({ template }) {
     if (hours < 10) hours = '0' + hours;
 
     let mins = date.getMinutes();
-    if (mins < 10) min = '0' + mins;
+    if (mins < 10) mins = '0' + mins;
 
     let secs = date.getSeconds();
     if (secs < 10) secs = '0' + secs;
@@ -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/09-classes/01-class/1-rewrite-to-class/task.md b/1-js/09-classes/01-class/1-rewrite-to-class/task.md
new file mode 100644
index 0000000000..3399b2c343
--- /dev/null
+++ b/1-js/09-classes/01-class/1-rewrite-to-class/task.md
@@ -0,0 +1,13 @@
+importance: 5
+
+---
+
+# 重写 class 声明
+
+<<<<<<< HEAD:1-js/07-object-oriented-programming/09-class/1-rewrite-to-class/task.md
+按要求重写所有的 `Clock` 类声明方式，把所有类定义方式从 prototype 变为“现代”的 "class" 语法。
+=======
+The `Clock` class is written in functional style. Rewrite it the "class" syntax.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/01-class/1-rewrite-to-class/task.md
+
+P.S. clock 仅在 console 中打印，请打开 console 查看。
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 0000000000..30a958df71
--- /dev/null
+++ b/1-js/09-classes/01-class/article.md
@@ -0,0 +1,351 @@
+
+# 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 if 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` declaration 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"
+// (no such term in the spec, but that's similar to Named Function Expression)
+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
+
+Just like literal objects, classes may 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.
+```
+
+The class declaration creates getters and setters in `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
+
+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 (the one that we provide as `constructor`), while methods, getters and settors 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 0000000000..dc8b756794
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 0000000000..aaa53708fa
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 0000000000..dcb4ffe59a
--- /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 64%
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 c710b9da9b..d701c0caeb 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,21 +1,21 @@
 class Clock {
   constructor({ template }) {
-    this._template = template;
+    this.template = template;
   }
 
-  _render() {
+  render() {
     let date = new Date();
 
     let hours = date.getHours();
     if (hours < 10) hours = '0' + hours;
 
     let mins = date.getMinutes();
-    if (mins < 10) min = '0' + mins;
+    if (mins < 10) mins = '0' + mins;
 
     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 4eb12381f9..ca613ca5e5 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 0000000000..f76a436238
--- /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 64%
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 c710b9da9b..d701c0caeb 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,21 +1,21 @@
 class Clock {
   constructor({ template }) {
-    this._template = template;
+    this.template = template;
   }
 
-  _render() {
+  render() {
     let date = new Date();
 
     let hours = date.getHours();
     if (hours < 10) hours = '0' + hours;
 
     let mins = date.getMinutes();
-    if (mins < 10) min = '0' + mins;
+    if (mins < 10) mins = '0' + mins;
 
     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 0000000000..c0609858b8
--- /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/09-classes/02-class-inheritance/2-clock-class-extended/task.md b/1-js/09-classes/02-class-inheritance/2-clock-class-extended/task.md
new file mode 100644
index 0000000000..91bb3b0f89
--- /dev/null
+++ b/1-js/09-classes/02-class-inheritance/2-clock-class-extended/task.md
@@ -0,0 +1,20 @@
+importance: 5
+
+---
+
+# 继承 clock
+
+我们有一个 `Clock` 类。到目前为止，它每秒都会打印时间。
+
+<<<<<<< HEAD:1-js/07-object-oriented-programming/10-class-inheritance/2-clock-class-extended/task.md
+从 `Clock` 继承并创建一个新的类 `ExtendedClock`，同时添加一个参数 `precision` —— 每次 "ticks" 之间间隔的毫秒数，默认是 `1000`（1秒）。
+
+- 你的代码在 `extended-clock.js` 文件里
+- 不要修改原来的 `clock.js`。只继承它。
+=======
+
+[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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/02-class-inheritance/2-clock-class-extended/task.md
+
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 0000000000..c610e28c3e
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 0000000000..4819c7f798
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 0000000000..0d887dbc0e
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 0000000000..af09271a91
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 66%
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 8989dfc51e..579e60e334 100644
--- a/1-js/07-object-oriented-programming/10-class-inheritance/article.md
+++ b/1-js/09-classes/02-class-inheritance/article.md
@@ -1,40 +1,94 @@
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/10-class-inheritance/article.md
 # 类继承和 super
 
 类可以继承另外一个类。这是一个非常棒的语法，在技术上是它基于原型继承实现的。
 
 为了继承另外一个类，我们需要在括号 `{..}` 前指定 `"extends"` 和父类
+=======
+# Class 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 braces `{..}`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/02-class-inheritance/article.md
 
 这里我们写一个继承自 `Animal` 的 `Rabbit`：
 
 ```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"
 *!*
+<<<<<<< HEAD:1-js/07-object-oriented-programming/10-class-inheritance/article.md
 // 从 Animal 继承
+=======
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/02-class-inheritance/article.md
 class Rabbit extends Animal {
+*/!*
   hide() {
     alert(`${this.name} hides!`);
   }
 }
-*/!*
 
 let rabbit = new Rabbit("White Rabbit");
 
@@ -42,11 +96,23 @@ rabbit.run(5); // 白色兔子会以速度 5 奔跑。
 rabbit.hide(); // 白色兔子藏了起来！
 ```
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/10-class-inheritance/article.md
 就如你期望的那样，也正如我们之前所见，`extends` 关键字实际上是给 `Rabbit.prototype` 添加了一个属性 `[[Prototype]]`，并且它会指向 `Animal.prototype`。
 
 ![](animal-rabbit-extends.png)
 
 所以，现在 `rabbit` 即可以访问它自己的方法，也可以访问 `Animal` 的方法。
+=======
+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, 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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/02-class-inheritance/article.md
 
 ````smart header="Any expression is allowed after `extends`"
 类语法不仅允许在 `extends` 后指定一个类，也允许指定任何表达式。
@@ -163,7 +229,11 @@ setTimeout(function() { super.stop() }, 1000);
 
 到目前为止，`Rabbit` 还没有自己的 `constructor`。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/10-class-inheritance/article.md
 根据[规范](https://tc39.github.io/ecma262/#sec-runtime-semantics-classdefinitionevaluation)，如果一个类继承了另一个类并且没有构造函数，那么将生成以下构造函数：
+=======
+According to the [specification](https://tc39.github.io/ecma262/#sec-runtime-semantics-classdefinitionevaluation), if a class extends another class and has no `constructor`, then the following "empty" `constructor` is generated:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/02-class-inheritance/article.md
 
 ```js
 class Rabbit extends Animal {
@@ -263,6 +333,7 @@ alert(rabbit.earLength); // 10
 
 让我们再深入的去研究下 `super`。顺便说一句，我们会发现一些有趣的事情。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/10-class-inheritance/article.md
 首先要说的是，从我们迄今为止学到的知识来看，`super` 是不可能运行的。
 
 的确是这样，让我们问问自己，在技术上它是如何实现的？当一个对象方法运行时，它会将当前对象作为 `this`。如果之后我们调用 `super.method()`，那么如何检索 `method`？我们想当然地认为需要从当前对象的原型中获取 `method`。但是从技术上讲，我们（或者 JavaScript 的引擎）可以做到这一点吗？
@@ -272,6 +343,17 @@ alert(rabbit.earLength); // 10
 让我们尝试去这么做看看。简单起见，我们不使用类，只使用普通对象。
 
 在这里，`rabbit.eat()` 会调用父对象的 `animal.eat()` 方法：
+=======
+First to say, from all that we've learned till now, it's impossible for `super` to work at all!
+
+Yeah, indeed, let's ask ourselves, how it could technically work? When an object method runs, it gets the current object as `this`. If we call `super.method()` then, it needs to retrieve the `method` from the prototype of the current object.
+
+The task may seem simple, but it isn't. The engine knows the current object `this`, so it could get the parent `method` as `this.__proto__.method`. Unfortunately, such a "naive" solution won't work.
+
+Let's demonstrate the problem. Without classes, using plain objects for the sake of simplicity.
+
+In the example below, `rabbit.__proto__ = animal`. Now let's try: in `rabbit.eat()` we'll call `animal.eat()`, using `this.__proto__`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/02-class-inheritance/article.md
 
 ```js run
 let animal = {
@@ -369,6 +451,7 @@ longEar.eat(); // Error: Maximum call stack size exceeded
 
 为了提供解决方法，JavaScript 为函数额外添加了一个特殊的内部属性：`[[HomeObject]]`。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/10-class-inheritance/article.md
 **当一个函数被定义为类或者对象方法时，它的 `[[HomeObject]]` 属性就成为那个对象**
 
 这实际上违反了 “解除绑定” 功能的想法，因为函数会记录他们的对象，并且 `[[HomeObject]]` 不能被改变，所以这个绑定是永久的。因此这是一个非常重要的语言变化。
@@ -376,11 +459,18 @@ longEar.eat(); // Error: Maximum call stack size exceeded
 但是这种改变是安全的。`[[HomeObject]]` 只有使用 `super` 调用父类的方法是才会被使用。所以它不会破坏兼容性。
 
 让我们看看它是如何帮助 `super` 运行的 —— 我们再次使用普通对象：
+=======
+When a function is specified as a class or object method, its `[[HomeObject]]` property becomes that object.
+
+Then `super` uses it to resolve the parent prototype and its methods.
+
+Let's see how it works, first with plain objects:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/02-class-inheritance/article.md
 
 ```js run
 let animal = {
   name: "Animal",
-  eat() {         // [[HomeObject]] == animal
+  eat() {         // animal.eat.[[HomeObject]] == animal
     alert(`${this.name} eats.`);
   }
 };
@@ -388,7 +478,7 @@ let animal = {
 let rabbit = {
   __proto__: animal,
   name: "Rabbit",
-  eat() {         // [[HomeObject]] == rabbit
+  eat() {         // rabbit.eat.[[HomeObject]] == rabbit
     super.eat();
   }
 };
@@ -396,16 +486,18 @@ let rabbit = {
 let longEar = {
   __proto__: rabbit,
   name: "Long Ear",
-  eat() {         // [[HomeObject]] == longEar
+  eat() {         // longEar.eat.[[HomeObject]] == longEar
     super.eat();
   }
 };
 
 *!*
+// works correctly
 longEar.eat();  // Long Ear eats.
 */!*
 ```
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/10-class-inheritance/article.md
 每个方法都会在内部的 `[[HomeObject]]` 属性上标记它的对象。然后 `super` 利用它来解析父级原型。
 
 `[[HomeObject]]` 是为类和简单对象中定义的方法定义的。但是对于对象，方法必须按照给定的方式定义：使用 `method()`，而不是 `"method: function()"`。
@@ -416,16 +508,35 @@ longEar.eat();  // Long Ear eats.
 let animal = {
   eat: function() { // 应该使用简短语法：eat() {...}
     // ...
+=======
+It works as intended, due to `[[HomeObject]]` mechanics. A method, such as `longEar.eat`, knows its `[[HomeObject]]` and takes the parent method from its prototype. Without any use of `this`.
+
+### Methods are not "free"
+
+As we've known before, generally functions are "free", not bound to objects in JavaScript. So they can be copied between objects and called with another `this`.
+
+The very existance of `[[HomeObject]]` violates that principle, because methods remember their objects. `[[HomeObject]]` can't be changed, so this bond is forever.
+
+The only place in the language where `[[HomeObject]]` is used -- is `super`. So, if a method does not use `super`, then we can still consider it free and copy between objects. But with `super` things may go wrong.
+
+Here's the demo of a wrong `super` call:
+
+```js run
+let animal = {
+  sayHi() {
+    console.log(`I'm an animal`);
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/02-class-inheritance/article.md
   }
 };
 
 let rabbit = {
   __proto__: animal,
-  eat: function() {
-    super.eat();
+  sayHi() {
+    super.sayHi();
   }
 };
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/10-class-inheritance/article.md
 *!*
 rabbit.eat();  // 调用 super 报错（因为没有 [[HomeObject]]）
 */!*
@@ -448,8 +559,15 @@ class Animal {
   run(speed = 0) {
     this.speed += speed;
     alert(`${this.name} runs with speed ${this.speed}.`);
+=======
+let plant = {
+  sayHi() {
+    console.log("I'm a plant");
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/02-class-inheritance/article.md
   }
+};
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/10-class-inheritance/article.md
   static compare(animalA, animalB) {
     return animalA.speed - animalB.speed;
   }
@@ -507,9 +625,34 @@ alert(Rabbit.prototype.__proto__ === Animal.prototype);
 `Object` 有 `Object.defineProperty`，`Object.keys` 等等的方法，但是 `Array`，`Date` 等等并不会继承他们。
 
 这里有一张图来描述 `Date` 和 `Object` 的结构：
+=======
+let tree = {
+  __proto__: plant,
+*!*
+  sayHi: rabbit.sayHi // (*)
+*/!*
+};
+
+*!*
+tree.sayHi();  // I'm an animal (?!?)
+*/!*
+```
+
+A call to `tree.sayHi()` shows "I'm an animal". Definitevely wrong.
+
+The reason is simple:
+- In the line `(*)`, the method `tree.sayHi` was copied from `rabbit`. Maybe we just wanted to avoid code duplication?
+- So its `[[HomeObject]]` is `rabbit`, as it was created in `rabbit`. There's no way to change `[[HomeObject]]`.
+- The code of `tree.sayHi()` has `super.sayHi()` inside. It goes up from `rabbit` and takes the method from `animal`.
 
-![](object-date-inheritance.png)
+![](super-homeobject-wrong.png)
 
+### Methods, not function properties
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/02-class-inheritance/article.md
+
+`[[HomeObject]]` is defined for methods both in classes and in plain objects. But for objects, methods must be specified exactly as `method()`, not as `"method: function()"`.
+
+<<<<<<< HEAD:1-js/07-object-oriented-programming/10-class-inheritance/article.md
 请注意，`Date` 和 `Object` 之间没有关联。`Object` 和 `Date` 都是独立存在的。`Date.prototype` 继承自 `Object.prototype`，但也仅此而已。
 
 这种差异是由于历史原因而存在的：在 JavaScript 语言被创建时，并没有考虑过类语法和静态方法的继承
@@ -549,24 +692,39 @@ arr.constructor === PowerArray
 更重要的是，我们可以定制这种行为。在这种情况下，如果存在静态的 getter `Symbol.species`，那么就会使用它的返回值作为构造函数。
 
 举个例子，这里因为有 `Symbol.species`，像 `map`，`filter` 这样的内置方法将返回“普通”数组：
+=======
+The difference may be non-essential for us, but it's important for JavaScript.
+
+In the example below a non-method syntax is used for comparison. `[[HomeObject]]` property is not set and the inheritance doesn't work:
 
 ```js run
-class PowerArray extends Array {
-  isEmpty() {
-    return this.length === 0;
+let animal = {
+  eat: function() { // should be the short syntax: eat() {...}
+    // ...
+  }
+};
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/02-class-inheritance/article.md
+
+let rabbit = {
+  __proto__: animal,
+  eat: function() {
+    super.eat();
   }
+};
 
 *!*
+<<<<<<< HEAD:1-js/07-object-oriented-programming/10-class-inheritance/article.md
   // 内置函数会使用它作为构造函数
   static get [Symbol.species]() {
     return Array;
   }
+=======
+rabbit.eat();  // Error calling super (because there's no [[HomeObject]])
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/02-class-inheritance/article.md
 */!*
-}
-
-let arr = new PowerArray(1, 2, 5, 10, 50);
-alert(arr.isEmpty()); // false
+```
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/10-class-inheritance/article.md
 // filter 使用 arr.constructor[Symbol.species] 作为构造函数创建了新数组
 let filteredArr = arr.filter(item => item >= 10);
 
@@ -577,3 +735,19 @@ alert(filteredArr.isEmpty()); // Error: filteredArr.isEmpty is not a function
 ```
 
 在一些高级的场景中，我们可以使用它从结果值中剔除一些不需要的扩展功能。又或者可以进一步扩展它。
+=======
+## Summary
+
+1. To extend a class: `class Child extends Parent`:
+    - That means `Child.prototype.__proto__` will be `Parent.prototype`, so methods are inherited.
+2. When overriding a constructor:
+    - We must call parent constructor as `super()` in `Child` constructor before using `this`.
+3. When overriding another method:
+    - We can use `super.method()` in a `Child` method to call `Parent` method.
+4. Internals:
+    - Methods remember their class/object in the internal `[[HomeObject]]` property. That's how `super` resolves parent methods.
+    - So it's not safe to copy a method with `super` from one object to another.
+
+Also:
+- Arrow functions don't have own `this` or `super`, so they transparently fit into the surrounding context.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/02-class-inheritance/article.md
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 0000000000..8d30622ceb
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 0000000000..00f6bd80d0
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 0000000000..f8afbbcd64
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 0000000000..cf5aa6554f
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 0000000000..a6f8964e6c
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 0000000000..2e3f4d7ffa
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 0000000000..79351a7540
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 0000000000..346574e0c6
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 0000000000..3d3b78cca5
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 0000000000..a923d10e55
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/super-homeobject-wrong.png b/1-js/09-classes/02-class-inheritance/super-homeobject-wrong.png
new file mode 100644
index 0000000000..b1871dc722
Binary files /dev/null and b/1-js/09-classes/02-class-inheritance/super-homeobject-wrong.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 0000000000..e68ed70e7e
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 0000000000..037d075874
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 0000000000..c5e7e3e490
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 0000000000..de434af2cf
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 0000000000..b940e04c86
--- /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("HTML", new Date(2019, 1, 1)),
+  new Article("CSS", new Date(2019, 0, 1)),
+  new Article("JavaScript", new Date(2019, 11, 1))
+];
+
+*!*
+articles.sort(Article.compare);
+*/!*
+
+alert( articles[0].title ); // CSS
+```
+
+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` 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
+
+// the next step up leads to Function.prototype
+alert(Animal.__proto__ === Function.prototype); // true
+
+// 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 0000000000..78d6c78f59
--- /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 choice.
+
+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 MegaCoffeeMachine 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 0000000000..60f84664d1
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 0000000000..ee26e1c064
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 0000000000..f85aa02425
--- /dev/null
+++ b/1-js/09-classes/05-extend-natives/article.md
@@ -0,0 +1,90 @@
+
+# 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 using exactly `new PowerArray`, not basic `Array`. That's actually very cool, because we can keep using `PowerArray` methods further on the result.
+
+Even more, we can customize that behavior.
+
+We can add a special static getter `Symbol.species` to the class. If exists, it should return the constructor that JavaScript will use internally to create new entities in `map`, `filter` and so on.
+
+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.
+
+As we already know, native classes extend each other. For instance, `Array` extends `Object`.
+
+Normally, when one class extends another, both static and non-static methods are inherited.
+
+So, if `Rabbit extends Animal`, then:
+
+1. `Rabbit.methods` are callable for `Animal.methods`, because `Rabbit.[[Prototype]] = Animal`.
+2. `new Rabbit().methods` are also available, because `Rabbit.prototype.[[Prototype]] = Animal.prototype`.
+
+That's thoroughly explained in the chapter [](info:static-properties-methods#statics-and-inheritance).
+
+But built-in classes are an exception. They don't inherit statics `(1)` from each other.
+
+For example, both `Array` and `Date` inherit from `Object`, so their instances have methods from `Object.prototype`. But  `Array.[[Prototype]]` does not point to `Object`. So there's `Object.keys()`, but not `Array.keys()` and `Date.keys()`.
+
+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 0000000000..73020a49e8
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 0000000000..6520f9e265
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 80%
rename from 1-js/07-object-oriented-programming/11-instanceof/article.md
rename to 1-js/09-classes/06-instanceof/article.md
index f2e74d31f6..0d96696e98 100644
--- a/1-js/07-object-oriented-programming/11-instanceof/article.md
+++ b/1-js/09-classes/06-instanceof/article.md
@@ -46,14 +46,26 @@ alert( arr instanceof Object ); // true
 
 有一点需要留意，`arr` 同时还隶属于 `Object` 类。因为从原型上来讲，`Array` 是继承自 `Object` 类的。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/11-instanceof/article.md
 `instanceof` 在检测中会将原型链考虑在内，此外，还能借助静态方法 `Symbol.hasInstance` 来改善检测效果。
+=======
+The `instanceof` operator examines the prototype chain for the check, but we can set a custom logic the static method `Symbol.hasInstance`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/06-instanceof/article.md
 
 `obj instanceof Class` 语句的大致执行过程如下：
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/11-instanceof/article.md
 1. 如果提供了静态方法 `Symbol.hasInstance`，那就直接用这个方法进行检测：
 
     ```js run
     // 假设具有 canEat 属性的对象为动物类
+=======
+1. If there's a static method `Symbol.hasInstance`, then just call it: `Class[Symbol.hasInstance](obj)`. It should return either `true` or `false`. We're done.
+    For example: 
+
+    ```js run
+    // setup instanceOf check that assumes that anything that canEat is an animal
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/06-instanceof/article.md
     class Animal {
       static [Symbol.hasInstance](obj) {
         if (obj.canEat) return true;
@@ -61,10 +73,18 @@ alert( arr instanceof Object ); // true
     }
 
     let obj = { canEat: true };
+<<<<<<< HEAD:1-js/07-object-oriented-programming/11-instanceof/article.md
     alert(obj instanceof Animal); // 返回 true：调用 Animal[Symbol.hasInstance](obj)
     ```
 
 2. 大部分的类是没有 `Symbol.hasInstance` 方法的，这时会检查 `Class.prototype` 是否与 `obj` 的原型链中的任何一个原型相等。
+=======
+
+    alert(obj instanceof Animal); // true: Animal[Symbol.hasInstance](obj) is called
+    ```
+
+2. Most classes do not have `Symbol.hasInstance`. In that case, the standard logic is used: `obj instanceOf Classs` checks whether `Class.prototype` equals to one of prototypes in the `obj` prototype chain.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/06-instanceof/article.md
 
     简而言之，是这么比较的：
     ```js
@@ -117,7 +137,11 @@ alert( rabbit instanceof Rabbit ); // false
 
 所以，为了谨慎起见，最好避免修改 `prototype`。
 
+<<<<<<< HEAD:1-js/07-object-oriented-programming/11-instanceof/article.md
 ## 福利：使用 Object 的 toString 方法来揭示类型
+=======
+## Bonus: Object.prototype.toString for the type
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/06-instanceof/article.md
 
 大家都知道，一个普通对象被转化为字符串时为 `[object Object]`：
 
@@ -182,7 +206,11 @@ alert( {}.toString.call(user) ); // [object User]
 大部分和环境相关的对象也有这个属性。以下输出可能因浏览器不同而异：
 
 ```js run
+<<<<<<< HEAD:1-js/07-object-oriented-programming/11-instanceof/article.md
 // 环境相关对象和类的 toStringTag：
+=======
+// toStringTag for the environment-specific object and class:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/09-classes/06-instanceof/article.md
 alert( window[Symbol.toStringTag]); // window
 alert( XMLHttpRequest.prototype[Symbol.toStringTag] ); // XMLHttpRequest
 
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 0000000000..ad0fc77ab3
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 0000000000..c25b166b3f
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 0000000000..6142ce7fcc
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 0000000000..ccbd743002
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 0000000000..87846ef6ba
--- /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 74%
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
index 03750a1763..1e3182cf76 100644
--- 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
@@ -33,6 +33,10 @@ importance: 5
     */!*
     ```
 
+<<<<<<< HEAD:1-js/08-error-handling/1-try-catch/1-finally-or-code-after/task.md
 我们只是需要在代码执行完之后，清除工作空间，而不管是不是在执行的过程中遇到异常。
+=======
+We definitely need the cleanup after the work, doesn't matter if there was an error or not.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/1-try-catch/1-finally-or-code-after/task.md
 
 那么，是用 `finally` 好呢还是两种方式都一样？如果哪种更好，请举例说明在什么情况下它会更好？
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 81%
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 696ec18247..8b5ce9feac 100644
--- a/1-js/08-error-handling/1-try-catch/article.md
+++ b/1-js/10-error-handling/1-try-catch/article.md
@@ -68,7 +68,7 @@ try {
 
     } catch(err) {
 
-      alert(`Error has occured!`); // *!*(3) <--*/!*
+      alert(`Error has occurred!`); // *!*(3) <--*/!*
 
     }
 
@@ -108,14 +108,24 @@ try {
 }
 ```
 
+<<<<<<< HEAD:1-js/08-error-handling/1-try-catch/article.md
 因为 `try..catch` 包裹了计划要执行的 `setTimeout` 函数。但是函数本身要稍后才能执行，这时引擎已经离开了 `try..catch` 结构。
+=======
+That's because the function itself is executed later, when the engine has already left the `try..catch` construct.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/1-try-catch/article.md
 
 要捕捉到计划中将要执行的函数中的异常，那么 `try..catch` 必须在这个函数之中：
 ```js run
 setTimeout(function() {
+<<<<<<< HEAD:1-js/08-error-handling/1-try-catch/article.md
   try {
     noSuchVariable; // try..catch 处理异常！
   } catch (e) {
+=======
+  try {    
+    noSuchVariable; // try..catch handles the error!
+  } catch {
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/1-try-catch/article.md
     alert( "error is caught here!" );
   }
 }, 1000);
@@ -165,6 +175,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
+}
+```
 
 ## 使用 "try..catch"
 
@@ -194,7 +217,11 @@ alert( user.age );  // 30
 
 得到报错之后我们就应该满意了吗？当然不！
 
+<<<<<<< HEAD:1-js/08-error-handling/1-try-catch/article.md
 如果这样做，当拿到的数据出错，用户就不会知道（除非他们打开开发者控制台）。代码执行失败却没有提示信息会导致糟糕的用户体验。
+=======
+This way, if something's wrong with the data, the visitor will never know that (unless they open the developer console). And people really don't like when something "just dies" without any error message.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/1-try-catch/article.md
 
 让我们来用 `try..catch` 来处理这个错误：
 
@@ -255,7 +282,11 @@ try {
 throw <error object>
 ```
 
+<<<<<<< HEAD:1-js/08-error-handling/1-try-catch/article.md
 技术上讲，我们可以使用任何东西来作为一个异常对象。甚至可以是基础类型，比如数字或者字符串。但是更好的方式是用对象，尤其是有 `name` 和 `message` 属性的对象（某种程度上和内置的异常有可比性）。
+=======
+Technically, we can use anything as an error object. That may be even a primitive, like a number or a string, but it's better to use objects, preferably with `name` and `message` properties (to stay somewhat compatible with built-in errors).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/1-try-catch/article.md
 
 JavaScript 有很多标准异常的内置的构造器：`Error`、 `SyntaxError`、`ReferenceError`、`TypeError` 和其他的。我们也可以用他们来创建异常对象。
 
@@ -325,7 +356,11 @@ try {
 
 ## 再次抛出异常
 
+<<<<<<< HEAD:1-js/08-error-handling/1-try-catch/article.md
 上面的例子中，我们用 `try..catch` 处理没有被正确返回的数据，但是也有可能在 `try {...}` 代码块内发生**另一个预料之外的**异常，例如变量未定义或者其他不是返回的数据不正确的异常。
+=======
+In the example above we use `try..catch` to handle incorrect data. But is it possible that *another unexpected error* occurs within the `try {...}` block? Like a programming error (variable is not defined) or something else, not just that "incorrect data" thing.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/1-try-catch/article.md
 
 例如：
 
@@ -342,7 +377,11 @@ try {
 }
 ```
 
+<<<<<<< HEAD:1-js/08-error-handling/1-try-catch/article.md
 当然，一切皆有可能。程序员也是会犯错的。即使是一些开源的被数百万人用了几十年的项目 —— 一个严重的 bug 因为他引发的严重的黑客事件被发现（比如发生在 `ssh` 工具上的黑客事件）。
+=======
+Of course, everything's possible! Programmers do make mistakes. Even in open-source utilities used by millions for decades -- suddenly a bug may be discovered that leads to terrible hacks.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/1-try-catch/article.md
 
 对我们来说，`try..catch` 是用来捕捉“数据错误”的异常，但是 catch 本身会捕捉到**所有**来自于 `try` 的异常。这里，我们遇到了预料之外的错误，但是仍然抛出了 `"JSON Error"` 的信息，这是不正确的，同时也会让我们的代码变得更难调试。
 
@@ -476,7 +515,11 @@ try {
 1. 如果对于 "Make an error?" 你的回答是 "Yes"，那么执行 `try -> catch -> finally`。
 2. 如果你的回答是 "No"，那么执行 `try -> finally`。
 
+<<<<<<< HEAD:1-js/08-error-handling/1-try-catch/article.md
 `finally` 的语法通常用在：我们在 `try..catch` 之前开始一个操作，不管在该代码块中执行的结果怎样，我们都想结束的时候执行某个操作。
+=======
+The `finally` clause is often used when we start doing something and want to finalize it in any case of outcome.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/1-try-catch/article.md
 
 比如，生成斐波那契数的函数 `fib(n)` 的执行时间，通常，我们在开始和结束的时候测量。但是，如果该函数在被调用的过程中发生异常，就如执行下面的代码就会返回负数或者非整数的异常。
 
@@ -508,14 +551,18 @@ try {
 }
 */!*
 
-alert(result || "error occured");
+alert(result || "error occurred");
 
 alert( `execution took ${diff}ms` );
 ```
 
 你可以通过后面的不同的输入来检验上面代码的执行：先在 `prompt` 弹框中先输入 `35` —— 它会正常执行，`try` 代码执行后执行 `finally` 里面的代码。然后再输入 `-1`，会立即捕获一个异常，执行时间将会是 `0ms`。两次的测量结果都是正确的。
 
+<<<<<<< HEAD:1-js/08-error-handling/1-try-catch/article.md
 换句话说，有两种方式退出这个函数的执行：`return` 或是 `throw`，`finally` 语法都能处理。
+=======
+In other words, the function may finish with `return` or `throw`, that doesn't matter. The `finally` clause executes in both cases.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/1-try-catch/article.md
 
 
 ```smart header="Variables are local inside `try..catch..finally`"
@@ -575,9 +622,15 @@ function func() {
 
 设想一下，`try..catch` 之外出现了一个严重的异常，代码停止执行，可能是因为编程异常或者其他更严重的异常。
 
+<<<<<<< HEAD:1-js/08-error-handling/1-try-catch/article.md
 那么，有没办法来应对这种情况呢？我们希望记录这个异常，给用户一些提示信息（通常，用户是看不到提示信息的），或者做一些其他操作。
 
 虽然没有这方面的规范，但是代码的执行环境一般会提供这种机制，因为这真的很有用。例如，Node.JS 有 [process.on('uncaughtException')](https://nodejs.org/api/process.html#process_event_uncaughtexception) 。对于浏览器环境，我们可以绑定一个函数到 [window.onerror](mdn:api/GlobalEventHandlers/onerror)，当遇到未知异常的时候，它就会执行。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/1-try-catch/article.md
 
 语法如下：
 
@@ -630,7 +683,11 @@ window.onerror = function(message, url, line, col, error) {
 
 ## 总结
 
+<<<<<<< HEAD:1-js/08-error-handling/1-try-catch/article.md
 `try..catch` 结构允许我们处理执行时的异常，它允许我们尝试执行代码，并且捕获执行过程中可能发生的异常。
+=======
+The `try..catch` construct allows to handle runtime errors. It literally allows to "try" running the code and "catch" errors that may occur in it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/1-try-catch/article.md
 
 语法如下：
 
@@ -653,7 +710,13 @@ try {
 - `name` —— 异常名称（异常对象的构造函数的名称）。
 - `stack`（没有标准） —— 异常发生时的调用栈。
 
+<<<<<<< HEAD:1-js/08-error-handling/1-try-catch/article.md
 我们也可以通过使用 `throw` 运算符来生成自定义的异常。技术上来讲，`throw` 的参数没有限制，但是通常它是一个继承自内置的 `Error` 类的异常对象。更对关于异常的扩展，请看下个章节。
+=======
+If an error object 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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/1-try-catch/article.md
 
 重新抛出异常，是一种异常处理的基本模式：`catch` 代码块通常处理某种已知的特定类型的异常，所以它应该抛出其他未知类型的异常。
 
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 0000000000..8b37753814
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 0000000000..f85eb63218
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 78%
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 e4e458f753..3e3d118557 100644
--- a/1-js/08-error-handling/2-custom-errors/article.md
+++ b/1-js/10-error-handling/2-custom-errors/article.md
@@ -6,7 +6,11 @@
 
 JavaScript 允许我们在使用 `throw` 时带任何参数，所以从技术层面上说，我们自定义的错误不需要继承 `Error` 类，但如果我们继承了这个类，就能使用 `obj instanceof Error` 来鉴别错误对象，所以我们最好继承它。
 
+<<<<<<< HEAD:1-js/08-error-handling/2-custom-errors/article.md
 在我们进行开发时，我们自己的异常类通常是有层次结构的，例如 `HttpTimeoutError` 可能继承自 `HttpError` 等。
+=======
+As the application grows, our own errors naturally form a hierarchy, for instance `HttpTimeoutError` may inherit from `HttpError`, and so on.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/2-custom-errors/article.md
 
 ## 扩展错误
 
@@ -19,7 +23,11 @@ let json = `{ "name": "John", "age": 30 }`;
 
 在这里面，我们使用 `JSON.parse`。如果它接收到错误的 `json`，就会抛出 `SyntaxError`。
 
+<<<<<<< HEAD:1-js/08-error-handling/2-custom-errors/article.md
 但即使是格式正确的 `json`，也并不表示它就是可用的，对吧？它有可能会遗漏一些必要的数据。例如，缺失了对用户所必需的 `name` 和 `age` 属性。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/2-custom-errors/article.md
 
 函数 `readUser(json)` 不仅会读取 JSON，也会检查（验证）数据。如果没有所需要的字段，或者格式不正确，那也是错误。而这不是 `SyntaxError`，因为数据在语法上是正确的，但是有其他的错误。我们称之为 `ValidationError` 并且为之创建一个类。这种类型的错误也应该承载缺少的字段的信息。
 
@@ -126,7 +134,11 @@ try {
 
 使用 `instanceof` 的做法会好很多，因为我们在以后会扩展 `ValidationError`，创造一个它的子类型，例如 `PropertyRequiredError`。而 `instanceof` 对于新的继承类也适用。所以这是个长远的保证。
 
+<<<<<<< HEAD:1-js/08-error-handling/2-custom-errors/article.md
 还有一点很重要，在 `catch` 语句捕捉到未知的错误时，它会在抛出行 `(**)` 处重新抛出，`catch` 语句仅仅知道如何处理验证和语法错误，而其他错误（代码中的打印错误等）不应该被捕获。
+=======
+Also it's important that if `catch` meets an unknown error, then it rethrows it in the line `(**)`. The `catch` block only knows how to handle validation and syntax errors, other kinds (due to a typo in the code or other unknown ones) should fall through.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/2-custom-errors/article.md
 
 ## 更进一步的继承
 
@@ -185,7 +197,11 @@ try {
 
 这个 `PropertyRequiredError` 十分容易上手：我们只需要传递属性名：`new PropertyRequiredError(property)`。易懂的 `message` 属性将会由构造器提供。
 
+<<<<<<< HEAD:1-js/08-error-handling/2-custom-errors/article.md
 需要注意的是，在 `PropertyRequiredError` 构造器中的 `this.name` 是再次进行手动赋值的。这可能会造成冗余 —— 在创建每个自定义错误的时候都要进行赋值 `this.name = <class name>`。但这并不是唯一的办法。我们可以创建自己的“基础异常”类，通过将 `this.constructor.name` 赋值给 `this.name` 来卸下我们肩上的负担，然后再进行继承。
+=======
+Please note that `this.name` in `PropertyRequiredError` constructor is again assigned manually. That may become a bit tedious -- to assign `this.name = <class name>` in every custom error class. 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 its constructor. And then inherit all ours custom errors from it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/2-custom-errors/article.md
 
 我们称其为 `MyError`。
 
@@ -218,7 +234,11 @@ alert( new PropertyRequiredError("field").name ); // PropertyRequiredError
 
 ## 包装异常
 
+<<<<<<< HEAD:1-js/08-error-handling/2-custom-errors/article.md
 上述代码中的函数 `readUser` 的目的就是“读取用户数据”，对吧？在此过程中可能会出现多个不同类型的异常，目前我们有 `SyntaxError` 和 `ValidationError`，但在将来，函数 `readUser` 将会不断壮大，新添加的代码或许会导致其他类型的异常。
+=======
+The purpose of the function `readUser` in the code above is "to read the user data", right? There may occur different kinds of errors in the process. Right now we have `SyntaxError` and `ValidationError`, but in the future `readUser` function may grow and probably generate other kinds of errors.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/2-custom-errors/article.md
 
 调用函数 `readUser` 的代码要能够处理这些异常。现在它在 `catch` 语句块中使用多个 `if` 语句来检测不同类型的异常以及抛出未知异常。但如果函数 `readUser` 抛出了多种异常 —— 我们扪心自问：我们真的需要一个接一个地处理它抛出的异常吗？
 
@@ -302,6 +322,12 @@ try {
 
 ## 总结
 
+<<<<<<< HEAD:1-js/08-error-handling/2-custom-errors/article.md
 - 我们能够正常地继承 `Error` 以及其他内置的错误类，只需要注意 `name` 属性以及不要忘了调用 `super`。
 - 大多数时候，我们应该使用 `instanceof` 来检测一些特定的异常。它也能够在继承中使用。但有时我们会发现来自第三方库的异常，并且不容易得到它的类。那么 `name` 属性就可用于这一类的检测。
 - 包装异常是一种广泛应用的技术，当一个函数处理低级别的异常时，用一个高级别的对象来报告错误。低级别的异常有时会变成这个对象的属性，就像上面例子中的 `err.cause`，但这并不严格要求。
+=======
+- We can inherit from `Error` and other built-in error classes normally, just need to take care of `name` property and don't forget to call `super`.
+- We can use `instanceof` to check for particular errors. It also works with inheritance. But sometimes we have an error object coming from the 3rd-party library and there's no easy way to get the class. Then `name` property can be used for such checks.
+- Wrapping exceptions is a widespread technique: a function handles low-level exceptions and creates higher-level errors instead of various low-level ones. Low-level exceptions sometimes become properties of that object like `err.cause` in the examples above, but that's not strictly required.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/10-error-handling/2-custom-errors/article.md
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 70%
rename from 6-async/01-callbacks/article.md
rename to 1-js/11-async/01-callbacks/article.md
index 817ec74a28..5074c9c375 100644
--- a/6-async/01-callbacks/article.md
+++ b/1-js/11-async/01-callbacks/article.md
@@ -23,7 +23,11 @@ function loadScript(src) {
 loadScript('/my/script.js');
 ```
 
+<<<<<<< HEAD:6-async/01-callbacks/article.md
 函数是**异步**调用的，因为动作不是此刻（加载脚本）完成的，而是之后。
+=======
+The function is called "asynchronously," because the action (script loading) finishes not now, but later.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/01-callbacks/article.md
 
 调用初始化脚本加载，然后继续执行。当脚本正在被加载时，下面的代码可能已经完成了执行，如果加载需要时间，那么同一时间，其他脚本可能也会被运行。
 
@@ -45,7 +49,11 @@ newFunction(); // 没有这个函数！
 */!*
 ```
 
+<<<<<<< HEAD:6-async/01-callbacks/article.md
 很明显，浏览器没有时间去加载脚本。因此，对新函数的立即调用失败了。`loadScript` 函数并没有提供追踪加载完成时方法。脚本加载然后最终的运行，仅此而已。但我们希望了解脚本何时加载完成，以使用其中的新函数和新变量。
+=======
+Naturally, the browser probably didn't have time to load the script. So the immediate call to the new function fails. As of now, the `loadScript` function doesn't provide a way to track the load completion. The script loads and eventually runs, that's all. But we'd like to know when it happens, to use new functions and variables from that script.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/01-callbacks/article.md
 
 我们将 `callback` 函数作为第二个参数添加至 `loadScript` 中，函数在脚本加载时被执行：
 
@@ -94,11 +102,19 @@ loadScript('https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.2.0/lodash.js', s
 
 这被称为“基于回调”的异步编程风格。异步执行某些动作的函数，应该提供一个在函数完成时可以运行的 `callback` 参数。
 
+<<<<<<< HEAD:6-async/01-callbacks/article.md
 我们 `loadScript` 中就是那么做的，但很明显这是一般性的方法。
+=======
+Here we did it in `loadScript`, but of course, it's a general approach.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/01-callbacks/article.md
 
 ## 在回调中回调
 
+<<<<<<< HEAD:6-async/01-callbacks/article.md
 如何顺序加载两个脚本：先是第一个，然后是第二个？
+=======
+How can we load two scripts sequentially: the first one, and then the second one after it?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/01-callbacks/article.md
 
 最明显的方法是将第二个 `loadScript` 调用放在回调中，就像这样：
 
@@ -140,7 +156,11 @@ loadScript('/my/script.js', function(script) {
 
 ## 处理错误
 
+<<<<<<< HEAD:6-async/01-callbacks/article.md
 上述示例中，我们并没有考虑错误因素。假如加载失败会如何？我们的回调应该可以立即对其做出响应。
+=======
+In the above examples we didn't consider errors. What if the script loading fails? Our callback should be able to react on that.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/01-callbacks/article.md
 
 这是可以跟踪错误的 `loadScript` 改进版：
 
@@ -173,15 +193,27 @@ loadScript('/my/script.js', function(error, script) {
 
 再一次强调，我们使用的 `loadScript` 方法是非常常规的。它被称为 "error-first callback" 风格。
 
+<<<<<<< HEAD:6-async/01-callbacks/article.md
 惯例是：
 1. `callback` 的第一个参数是为了错误发生而保留的。一旦发生错误，`callback(err)` 就会被调用。
 2. 第二个参数（如果有需要）用于成功的结果。此时 `callback(null, result1, result2…)` 将被调用。
+=======
+The convention is:
+1. The first argument of the `callback` is reserved for an error if it occurs. Then `callback(err)` is called.
+2. The second argument (and the next ones if needed) are for the successful result. Then `callback(null, result1, result2…)` is called.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/01-callbacks/article.md
 
 因此单个 `callback` 函数可以同时具有报告错误以及传递返回结果的作用。
 
+<<<<<<< HEAD:6-async/01-callbacks/article.md
 ## 回调金字塔
 
 从第一步可以看出，这是异步编码的一种可行性方案。的确如此，对于一个或两个的简单嵌套，这样的调用看起来非常好。
+=======
+## Pyramid of Doom
+
+From the first look, it's a viable way of asynchronous coding. And indeed it is. For one or maybe two nested calls it looks fine.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/01-callbacks/article.md
 
 但对于一个接一个的多个异步动作，代码就会变成这样：
 
@@ -220,7 +252,11 @@ loadScript('1.js', function(error, script) {
 
 如果嵌套变多，代码层次就会变深，维护难度也随之增加，尤其是如果我们有一个不是 `...` 的真实代码，就会包含更多的循环，条件语句等。
 
+<<<<<<< HEAD:6-async/01-callbacks/article.md
 这有时称为“回调地狱”或者“回调金字塔”。
+=======
+That's sometimes called "callback hell" or "pyramid of doom."
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/01-callbacks/article.md
 
 ![](callback-hell.png)
 
@@ -260,6 +296,7 @@ function step3(error, script) {
 };
 ```
 
+<<<<<<< HEAD:6-async/01-callbacks/article.md
 看到了么？效果一样，但是没有深层的嵌套了，因为我们使每个动作都有一个独立的顶层函数。
 
 这很有效，但代码看起来就像是一个被分裂的表格。你可能注意到了，它的可读性非常差。在阅读时，需要在块之间切换。这非常不方便，尤其是不熟悉代码的读者，他们甚至不知道该跳转到何处。
@@ -269,3 +306,14 @@ function step3(error, script) {
 或许还有更好的方法。
 
 幸运地是，有其他方法可以避免回调金字塔。其中一个最好的方法是使用 "promises"，我们将在下一章中详细描述。
+=======
+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.
+
+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.
+
+We'd like to have something better.
+
+Luckily, there are other ways to avoid such pyramids. One of the best ways is to use "promises," described in the next chapter.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/01-callbacks/article.md
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 0000000000..567ec284e6
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 0000000000..4d6b0ad703
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/1-js/11-async/02-promise-basics/article.md b/1-js/11-async/02-promise-basics/article.md
new file mode 100644
index 0000000000..bec6851afb
--- /dev/null
+++ b/1-js/11-async/02-promise-basics/article.md
@@ -0,0 +1,338 @@
+# Promise
+
+Imagine that you're a top singer, and fans ask day and night for your upcoming single.
+
+To get some relief, you promise to send it to them when it's published. You give your fans a list to which they can subscribe for updates. They can fill in their email addresses, so that when the song becomes available, all subscribed parties instantly receive it. And even if something goes very wrong, say, if plans to publish the song are cancelled, they will still be notified.
+
+Everyone is happy, because the people don't crowd you any more, and fans, because they won't miss the single.
+
+This is a real-life analogy for things we often have in programming:
+
+1. A "producing code" that does something and takes time. For instance, the code loads data over a network. That's a "singer".
+2. A "consuming code" that wants the result of the "producing code" once it's ready. Many functions  may need that result. These are the "fans".
+3. A *promise* is a special JavaScript object that links the "producing code" and the "consuming code" together. In terms of our analogy: this is the "subscription list". The "producing code" takes whatever time it needs to produce the promised result, and the "promise" makes that result available to all of the subscribed code when it's ready.
+
+The analogy isn't terribly accurate, because JavaScript promises are more complex than a simple subscription list: they have additional features and limitations. But it's fine to begin with.
+
+The constructor syntax for a promise object is:
+
+```js
+let promise = new Promise(function(resolve, reject) {
+  // executor (the producing code, "singer")
+});
+```
+
+The function passed to `new Promise` is called the *executor*. When the promise is created, this executor function runs automatically. It contains the producing code, that should eventually produce a result. In terms of the analogy above: the executor is the "singer".
+
+The resulting `promise` object has internal properties:
+
+- `state` — initially "pending", then changes to either "fulfilled" or "rejected",
+- `result` — an arbitrary value, initially `undefined`.
+
+When the executor finishes the job, it should call one of the functions that it gets as arguments:
+
+- `resolve(value)` — to indicate that the job finished successfully:
+    - sets `state` to `"fulfilled"`,
+    - sets `result` to `value`.
+- `reject(error)` — to indicate that an error occurred:
+    - sets `state` to `"rejected"`,
+    - sets `result` to `error`.
+
+![](promise-resolve-reject.png)
+
+Later we'll see how these changes become known to "fans".
+
+Here's an example of a Promise constructor and a simple executor function with its "producing code" (the `setTimeout`):
+
+```js run
+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);
+});
+```
+
+We can see two things by running the code above:
+
+1. The executor is called automatically and immediately (by the `new Promise`).
+2. The executor receives two arguments: `resolve` and `reject` — these functions are pre-defined by the JavaScript engine. So we don't need to create them. We only should call one of them when ready.
+
+After one second of "processing" the executor calls `resolve("done")` to produce the result:
+
+![](promise-resolve-1.png)
+
+That was an example of a successful job completion, a "fulfilled promise".
+
+And now an example of the executor rejecting the promise with an error:
+
+```js
+let promise = new Promise(function(resolve, reject) {
+  // after 1 second signal that the job is finished with an error
+  setTimeout(() => *!*reject(new Error("Whoops!"))*/!*, 1000);
+});
+```
+
+![](promise-reject-1.png)
+
+To summarize, the executor should do a job (something that takes time usually) and then call `resolve` or `reject` to change the state of the corresponding Promise object.
+
+The Promise that is either resolved or rejected is called "settled", as opposed to a initially "pending" Promise.
+
+````smart header="There can be only a single result or an error"
+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:
+
+```js
+let promise = new Promise(function(resolve, reject) {
+  resolve("done");
+
+  reject(new Error("…")); // ignored
+  setTimeout(() => resolve("…")); // ignored
+});
+```
+
+The idea is that a job done by the executor may have only one result or an error.
+
+Also, `resolve`/`reject` expect only one argument (or none) and will ignore additional arguments.
+````
+
+```smart header="Reject with `Error` objects"
+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`"
+In practice, an executor usually does something asynchronously and calls `resolve`/`reject` after some time, but it doesn't have to. We also can call `resolve` or `reject` immediately, like this:
+
+```js
+let promise = new Promise(function(resolve, reject) {
+  // not taking our time to do the job
+  resolve(123); // immediately give the result: 123
+});
+```
+
+For instance, this might happen when we start to do a job but then see that everything has already been completed and  cached.
+
+That's fine. We immediately have a resolved promise.
+````
+
+```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`/`.finally` for that. They are described below.
+```
+
+## 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 methods `.then`, `.catch` and `.finally`.
+
+### then
+
+The most important, fundamental one is `.then`.
+
+The syntax is:
+
+```js
+promise.then(
+  function(result) { *!*/* handle a successful result */*/!* },
+  function(error) { *!*/* handle an error */*/!* }
+);
+```
+
+The first argument of `.then` is a function that:
+
+1. runs when the promise is resolved, and
+2. receives the result.
+
+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 a reaction to a successfully resolved promise:
+
+```js run
+let promise = new Promise(function(resolve, reject) {
+  setTimeout(() => resolve("done!"), 1000);
+});
+
+// resolve runs the first function in .then
+promise.then(
+*!*
+  result => alert(result), // shows "done!" after 1 second
+*/!*
+  error => alert(error) // doesn't run
+);
+```
+
+The first function was executed.
+
+And in the case of a rejection -- the second one:
+
+```js run
+let promise = new Promise(function(resolve, reject) {
+  setTimeout(() => reject(new Error("Whoops!")), 1000);
+});
+
+// reject runs the second function in .then
+promise.then(
+  result => alert(result), // doesn't run
+*!*
+  error => alert(error) // shows "Error: Whoops!" after 1 second
+*/!*
+);
+```
+
+If we're interested only in successful completions, then we can provide only one function argument to `.then`:
+
+```js run
+let promise = new Promise(resolve => {
+  setTimeout(() => resolve("done!"), 1000);
+});
+
+*!*
+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:
+
+
+```js run
+let promise = new Promise((resolve, reject) => {
+  setTimeout(() => reject(new Error("Whoops!")), 1000);
+});
+
+*!*
+// .catch(f) is the same as promise.then(null, f)
+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.
+
+### finally
+
+Just like there's a `finally` clause in a regular `try {...} catch {...}`, there's `finally` in promises.
+
+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)
+```
+
+It's not exactly an alias of `then(f,f)` though. There are several important differences:
+
+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. A `finally` handler passes through results and errors to the next handler.
+
+    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
+    ```
+
+    And here there's an error in the promise, passed through `finally` to `catch`:
+
+    ```js run
+    new Promise((resolve, reject) => {
+      throw new Error("error");
+    })
+      .finally(() => alert("Promise ready"))
+      .catch(err => alert(err));  // <-- .catch handles the error object
+    ```  
+
+    That's very convenient, because `finally` is not meant to process a promise result. So it passes it through.
+
+    We'll talk more about promise chaining and result-passing between handlers in the next chapter.
+
+3. Last, but not least, `.finally(f)` is a more convenient syntax than `.then(f, f)`: no need to duplicate the function `f`.
+
+````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:
+
+```js run
+// an immediately resolved promise
+let promise = new Promise(resolve => resolve("done!"));
+
+promise.then(alert); // done! (shows up right now)
+```
+
+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.
+
+## Example: loadScript
+
+We've got the `loadScript` function for loading a script from the previous chapter.
+
+Here's the callback-based variant, just to remind us of it:
+
+```js
+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);
+}
+```
+
+Let's rewrite it using Promises.
+
+The new function `loadScript` will not require a callback. Instead, it will create and return a Promise object that resolves when the loading is complete. The outer code can add handlers (subscribing functions) to it using `.then`:
+
+```js run
+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 for ${src}`));
+
+    document.head.append(script);
+  });
+}
+```
+
+Usage:
+
+```js run
+let promise = loadScript("https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js");
+
+promise.then(
+  script => alert(`${script.src} is loaded!`),
+  error => alert(`Error: ${error.message}`)
+);
+
+promise.then(script => alert('One more handler to do something else!'));
+```
+
+We can immediately see a few benefits over the callback-based pattern:
+
+
+| 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 0000000000..3ae74879cf
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 0000000000..9eff3793c7
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 0000000000..b4bb51826b
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 0000000000..ecb4af35df
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 0000000000..6f0294f013
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 0000000000..b59301ff77
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 56%
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 9c74794c76..ecebd38186 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,15 @@
 这两段代码片段是否相等？换句话说，对于任何处理函数在任何情况下，它们的行为方式是否相同？
 
 ```js
-promise.then(f1, f2);
+promise.then(f1).catch(f2);
 ```
 
+<<<<<<< HEAD:6-async/03-promise-chaining/01-then-vs-catch/task.md
 对比：
+=======
+Versus:
+
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/03-promise-chaining/01-then-vs-catch/task.md
 ```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 0000000000..b2ba231ec5
--- /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/archive/promise/thenable.js b/1-js/11-async/03-promise-chaining/head.html
similarity index 52%
rename from archive/promise/thenable.js
rename to 1-js/11-async/03-promise-chaining/head.html
index b72c0871e7..0a0075fb92 100644
--- a/archive/promise/thenable.js
+++ b/1-js/11-async/03-promise-chaining/head.html
@@ -1,4 +1,5 @@
-function loadScript(src) {  
+<script>
+function loadScript(src) {
   return new Promise(function(resolve, reject) {
     let script = document.createElement('script');
     script.src = src;
@@ -9,15 +10,13 @@
     document.head.append(script);
   });
 }
-loadScript("/article/promise-chaining/one.js")
-  .then(script => {
-    return {
-      then(resolve, reject) {
-        setTimeout(() => resolve(script), 1000);
-      }
-    };
-  })
-  .then(function(script) {
-    alert(one);
-  });
+</script>
 
+<style>
+.promise-avatar-example {
+  border-radius: 50%;
+  position: fixed;
+  left: 10px;
+  top: 10px;
+}
+</style>
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 0000000000..712f57b828
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 0000000000..5b57be8094
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 0000000000..2643fde89d
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 0000000000..313e241cc9
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 0000000000..fab8a92ad4
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 0000000000..421b593599
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 0000000000..b13d20a9ef
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 0000000000..f0609c9467
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/1-js/11-async/04-promise-error-handling/01-error-async/task.md b/1-js/11-async/04-promise-error-handling/01-error-async/task.md
new file mode 100644
index 0000000000..78ea7d7b55
--- /dev/null
+++ b/1-js/11-async/04-promise-error-handling/01-error-async/task.md
@@ -0,0 +1,15 @@
+# setTimeout 中的错误
+
+<<<<<<< HEAD:6-async/03-promise-chaining/02-error-async/task.md
+你认为 `.catch` 会不会触发？请解释一下？
+=======
+What do you think? Will the `.catch` trigger? Explain your answer.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/04-promise-error-handling/01-error-async/task.md
+
+```js
+new Promise(function(resolve, reject) {
+  setTimeout(() => {
+    throw new Error("Whoops!");
+  }, 1000);
+}).catch(alert);
+```
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 0000000000..3424d099e1
--- /dev/null
+++ b/1-js/11-async/04-promise-error-handling/article.md
@@ -0,0 +1,345 @@
+
+# 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 site) 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 site, but the response is not valid JSON:
+
+```js run
+fetch('/') // fetch works fine now, the server responds with the HTML page
+*!*
+  .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 exception 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 the response.
+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 using `instanceof`.
+
+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(() => {
+    // successful promise handlers, one or more
+  }); // 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". There's no code to handle it.
+
+In practice, just like with a regular unhandled errors, it means that something has terribly gone wrong.
+
+What happens when a regular error occurs and is not caught by `try..catch`? The script dies. Similar thing happens with unhandled promise rejections.
+
+The JavaScript engine tracks such rejections and generates a global error in that case. You can see it in the console if you run the example above.
+
+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 ok not to use `.catch` at all, if there's no way to recover from an error.
+- 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)); // (*)
+    })
+*/!*
+    .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 0000000000..6c5893433a
--- /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/6-async/03-promise-chaining/head.html b/1-js/11-async/04-promise-error-handling/head.html
similarity index 62%
rename from 6-async/03-promise-chaining/head.html
rename to 1-js/11-async/04-promise-error-handling/head.html
index 31c6b42713..a0b7419623 100644
--- a/6-async/03-promise-chaining/head.html
+++ b/1-js/11-async/04-promise-error-handling/head.html
@@ -1,16 +1,4 @@
 <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}`);
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 0000000000..712f57b828
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 0000000000..5b57be8094
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 0000000000..2643fde89d
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 0000000000..313e241cc9
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 0000000000..fab8a92ad4
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 0000000000..421b593599
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 0000000000..b13d20a9ef
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 0000000000..f0609c9467
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 0000000000..8536e85a18
--- /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 72%
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
index 63e0bf1b70..de374c7847 100644
--- 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
@@ -12,7 +12,11 @@ Promise.all(
 
 这里我们有一个指向 `Promise.all` 的 `fetch(...)` promise 数组。
 
+<<<<<<< HEAD:6-async/04-promise-api/01-promise-errors-as-results/solution.md
 我们不能改变 `Promise.all` 的工作方式：如果它检测到 error，就会 reject 它。因此我们需要避免任何 error 发生。相反，如果 `fetch` 发生 error，我们需要将其视为“正常”结果。
+=======
+We can't change the way `Promise.all` works: if any promise rejects with an error, then `Promise.all` as a whole rejects with it. So we need to prevent any error from occurring. Instead, if a `fetch` error happens, we need to treat it as a "normal" result.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb: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 98%
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
index 241b09ad4a..c760ad8cd5 100644
--- 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
@@ -21,7 +21,7 @@
         alert(responses[0].status); // 200
         alert(responses[1].status); // 200
         alert(responses[2]); // TypeError: failed to fetch (text may vary)
-      ));
+      });
   </script>
 
 </body>
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 70%
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 086154c14f..f71d0f7de5 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
@@ -17,16 +17,24 @@ Promise.all(urls.map(url => fetch(url)))
     for(let response of responses) {
       alert(`${response.url}: ${response.status}`);
     }
-  ));
+  });
 ```
 
+<<<<<<< HEAD:6-async/04-promise-api/01-promise-errors-as-results/task.md
 问题是如果任何请求都失败了，那么 `Promise.all` 就会 reject error，而且所有的其他请求结果都会丢失。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/05-promise-api/01-promise-errors-as-results/task.md
 
 这并不好。
 
 修改代码会导致 `(*)` 行的 `responses` 数组包含成功响应的对象和失败时获取的 error 对象。
 
+<<<<<<< HEAD:6-async/04-promise-api/01-promise-errors-as-results/task.md
 例如，如果其中一个 URL 失效，那么就会变成这样：
+=======
+For instance, if one of the URLs is bad, then it should be like:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/05-promise-api/01-promise-errors-as-results/task.md
 
 ```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 60%
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 0382e5dda7..856c9f1aad 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,10 @@
 # 用 JSON fetch 的容错处理
 
+<<<<<<< HEAD:6-async/04-promise-api/02-promise-errors-as-results-2/task.md
 改进之前 <info:task/promise-errors-as-results> 任务的解决方案。我们现在只需要调用 `fetch`，但要从给定的 URL 中加载 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 the given URLs.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/05-promise-api/02-promise-errors-as-results-2/task.md
 
 这是改进后的代码：
 
@@ -25,7 +29,11 @@ Promise.all(urls.map(url => fetch(url)))
   });
 ```
 
+<<<<<<< HEAD:6-async/04-promise-api/02-promise-errors-as-results-2/task.md
 问题是如果任意请求都失败了，那么 `Promise.all` 就会 reject error，而且会丢失其他所有请求的结果。因此上述代码不易于容错，与上一个任务相同。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/05-promise-api/02-promise-errors-as-results-2/task.md
 
 请修改代码后，保证 `(*)` 的数组中包含请求成功解析后的 JSON 和错误的 JSON。
 
diff --git a/6-async/04-promise-api/article.md b/1-js/11-async/05-promise-api/article.md
similarity index 68%
rename from 6-async/04-promise-api/article.md
rename to 1-js/11-async/05-promise-api/article.md
index 448d78cc97..972953ee3c 100644
--- a/6-async/04-promise-api/article.md
+++ b/1-js/11-async/05-promise-api/article.md
@@ -35,13 +35,17 @@ function loadCached(url) {
   return fetch(url)
     .then(response => response.text())
     .then(text => {
-      cache[url] = text;
+      cache.set(url,text);
       return text;
     });
 }
 ```
 
+<<<<<<< HEAD:6-async/04-promise-api/article.md
 我们可以使用 `loadCached(url).then(…)`，因为函数保证会返回一个 promise。这是 `Promise.resolve` 在 `(*)` 行的目的：它确保了接口的统一性。我们可以在 `loadCached` 之后使用 `.then`。
+=======
+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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/05-promise-api/article.md
 
 ## Promise.reject
 
@@ -63,23 +67,37 @@ let promise = new Promise((resolve, reject) => reject(error));
 
 ## Promise.all
 
+<<<<<<< HEAD:6-async/04-promise-api/article.md
 该方法并行运行多个 promise，并等待所有 promise 准备就绪。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/05-promise-api/article.md
 
 语法：
 
 ```js
-let promise = Promise.all(iterable);
+let promise = Promise.all([...promises...]);
 ```
 
+<<<<<<< HEAD:6-async/04-promise-api/article.md
 它需要一个带有 promise 的 `iterable` 对象，技术上来说，它是可以迭代的，但通常情况下，它只是一个数组，而且会返回一个新的 promise。新的 promise 是在所有 promise 都被解决并拥有一个存放结果的数组之后才出现的。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/05-promise-api/article.md
 
 例如，下面的 `Promise.all` 在 3 秒之后被处理，然后它的结果就是一个 `[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 +150,6 @@ Promise.all(requests)
 
 例如：
 
-
 ```js run
 Promise.all([
   new Promise((resolve, reject) => setTimeout(() => resolve(1), 1000)),
@@ -145,12 +162,21 @@ Promise.all([
 
 这里的第二个 promise 在两秒内为 reject。这立即导致了对 `Promise.all` 的 reject。因此 `.catch` 被执行：避免 error 成为整个 `Promise.all` 的结果。
 
+<<<<<<< HEAD:6-async/04-promise-api/article.md
 重要的细节是 promise 没有提供 "cancel" 或 "abort" 执行方法。因此，其他 promise 会继续执行，并最终为 settle，但它们的结果会被忽略。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/05-promise-api/article.md
 
 有避免这种情况的方法：我们可以编写额外的代码到 `clearTimeout`（或在出现 error 时取消）promise，或者我们可以将 error 作为结果数组中的成员显示出来（参阅本章下的 task）。
 
+<<<<<<< HEAD:6-async/04-promise-api/article.md
 ````smart header="`Promise.all(iterable)` 允许在 `iterable` 中无 promise"
 通常 `Promise.all(iterable)` 接受可迭代的 promise（大多数情况是数组）。但如果这些对象中的任何一个不是 promise，它就会被封装进 `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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/05-promise-api/article.md
 
 例如。这里的结果是 `[1, 2, 3]`：
 
@@ -170,7 +196,11 @@ Promise.all([
 
 ## Promise.race
 
+<<<<<<< HEAD:6-async/04-promise-api/article.md
 与 `Promise.all` 类似，所有的 promise 都是可迭代的，但不会等待所有都完成 —— 只等待第一个完成（或者有 error），然后继续执行。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/05-promise-api/article.md
 
 语法是：
 
@@ -194,9 +224,16 @@ Promise.race([
 
 `Promise` 类有 4 中静态方法：
 
+<<<<<<< HEAD:6-async/04-promise-api/article.md
 1. `Promise.resolve(value)` —— 根据给定值返回 resolved promise，
 2. `Promise.reject(error)` —— 根据给定错误返回 rejected promise，
 3. `Promise.all(promises)` ——  等待所有的 promise 为 resolve 时返回存放它们结果的数组。如果任意给定的 promise 为 reject，那么它就会变成 `Promise.all` 的错误结果，所以所有的其他结果都会被忽略。
 4. `Promise.race(promises)` —— 等待第一个 promise 被解决，其结果/错误即为结果。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/05-promise-api/article.md
 
 这四个方法中，`Promise.all` 在实战中使用的最多。
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 0000000000..32f89971a8
--- /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 0000000000..948a60e075
--- /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 0000000000..b04795b86c
--- /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 0000000000..7c84912b57
--- /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.
+
+To be more precise, 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 without using the helper, 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 0000000000..1918ea04e9
--- /dev/null
+++ b/1-js/11-async/07-microtask-queue/article.md
@@ -0,0 +1,192 @@
+
+# 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* `.then`/`.catch`/`.finally` will still execute before these handlers .
+
+Here's the demo:
+
+```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 execution flow, as well as Node.js, is based on an *event loop*.
+
+"Event loop" is a process when the engine sleeps and waits for events. When they occur - handles them and sleeps again.
+
+Events may come either comes from external sources, like user actions, or just as the end signal of an internal task.
+
+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 chain of promise handlers that don't wait for anything, execute right one after another, then a `setTimeout` (or a user action handler) can never run in-between them.
+
+
+## Unhandled rejection
+
+Remember "unhandled rejection" event from the chapter <info:promise-error-handling>?
+
+Now we can describe how JavaScript finds out that a rejection was not handled.
+
+**"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 rejection appears again. Why? Because `unhandledrejection` is generated when the microtask queue is complete. The engine examines promises and, if any of them is in "rejected" state, then the event triggers.
+
+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` handlers 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 0000000000..f63c44296d
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 0000000000..27ece0219f
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 0000000000..efccc01408
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 0000000000..4d6ae5b425
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 71%
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
index 7242c5d04c..239fdc2d3b 100644
--- a/6-async/05-async-await/01-rewrite-async/solution.md
+++ b/1-js/11-async/08-async-await/01-rewrite-async/solution.md
@@ -19,9 +19,15 @@ loadJson('no-such-user.json')
 
 注释：
 
+<<<<<<< HEAD:6-async/05-async-await/01-rewrite-async/solution.md
 1. 函数 `loadUrl` 变成了 `async`。
 2. 所有内部 `.then` 都用 `await` 进行替换。
 3. 我们可以 `return response.json()` 而不是等待，就像这样：
+=======
+1. The function `loadJson` becomes `async`.
+2. All `.then` inside are replaced with `await`.
+3. We can `return response.json()` instead of awaiting for it, like this:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/01-rewrite-async/solution.md
 
     ```js
     if (response.status == 200) {
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 0000000000..7e2ab597eb
--- /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 0000000000..18d0e2ce75
--- /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 58%
rename from 6-async/05-async-await/article.md
rename to 1-js/11-async/08-async-await/article.md
index fec3612536..355ee1d598 100644
--- a/6-async/05-async-await/article.md
+++ b/1-js/11-async/08-async-await/article.md
@@ -1,10 +1,18 @@
 # Async/await
 
+<<<<<<< HEAD:6-async/05-async-await/article.md
 有一种特殊的语法可用一种更舒适的方式使用 promise，称为 "async/await"。它的易于理解和使用简单让人惊讶。
+=======
+There's a special syntax to work with promises in a more comfortable fashion, called "async/await". It's surprisingly easy to understand and use.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/article.md
 
 ## Async 函数
 
+<<<<<<< HEAD:6-async/05-async-await/article.md
 我们从 `async` 关键字开始。它可以放在函数前，就像这样：
+=======
+Let's start with the `async` keyword. It can be placed before a function, like this:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/article.md
 
 ```js
 async function f() {
@@ -12,7 +20,11 @@ async function f() {
 }
 ```
 
+<<<<<<< HEAD:6-async/05-async-await/article.md
 函数前的 "async" 意味着一件简单的事情：函数总是会返回 promise。如果代码中有 `return <non-promise>`，那么 JavaScript 就会自动将其封装到一个带有该值的 resolved promise 中。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/article.md
 
 例如，上述代码中返回一个带有结果 `1` 的 resolved promise，我们可以进行测试：
 
@@ -24,7 +36,11 @@ async function f() {
 f().then(alert); // 1
 ```
 
+<<<<<<< HEAD:6-async/05-async-await/article.md
 ...我们可以显式的返回一个 promise，结果相同：
+=======
+...We could explicitly return a promise, that would be the same as:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/article.md
 
 ```js run
 async function f() {
@@ -34,7 +50,11 @@ async function f() {
 f().then(alert); // 1
 ```
 
+<<<<<<< HEAD:6-async/05-async-await/article.md
 因此，`async` 确保函数返回一个 promise，并在其中封装非 promise。很简单对吧？但不仅仅如此。因为还有 `await` 关键字，它只在 `async` 函数中工作，而且非常酷。
+=======
+So, `async` ensures that the function returns a promise, and wraps non-promises in it. Simple enough, right? But not only that. There's another keyword, `await`, that works only inside `async` functions, and it's pretty cool.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/article.md
 
 ## Await
 
@@ -47,7 +67,11 @@ let value = await promise;
 
 `await` 关键字使 JavaScript 等待，直到 promise 得到解决并返回其结果。
 
+<<<<<<< HEAD:6-async/05-async-await/article.md
 下面是一个 promise 在 1s 之后 resolve 的例子：
+=======
+Here's an example with a promise that resolves in 1 second:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/article.md
 ```js run
 async function f() {
 
@@ -71,8 +95,13 @@ f();
 
 这是一种比 `promise.then` 更优雅地获取 promise 结果的语法，它更容易阅读和编写。
 
+<<<<<<< HEAD:6-async/05-async-await/article.md
 ````warn header="不能在常规函数中使用 `await`"
 如果我们尝试在非 async 函数中使用 `await`，就会产生语法错误：
+=======
+````warn header="Can't use `await` in regular functions"
+If we try to use `await` in non-async function, there would be a syntax error:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/article.md
 
 ```js run
 function f() {
@@ -83,6 +112,7 @@ function f() {
 }
 ```
 
+<<<<<<< HEAD:6-async/05-async-await/article.md
 如果我们忘记将 `async` 放在函数前，我们就会得到这样的错误。如前面所说的，`await` 只在 `async 函数` 中工作。
 ````
 
@@ -90,6 +120,15 @@ function f() {
 
 1. 我们需要用 `await` 替换 `.then` 调用。
 2. 此外，我们应该使用 `async` 函数来工作。
+=======
+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 the `showAvatar()` example from the chapter <info:promise-chaining> and rewrite it using `async/await`:
+
+1. We'll need to replace `.then` calls with `await`.
+2. Also we should make the function `async` for them to work.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/article.md
 
 ```js run
 async function showAvatar() {
@@ -121,8 +160,13 @@ showAvatar();
 
 非常整洁，而且易于阅读，对吧？比之前好多了。
 
+<<<<<<< HEAD:6-async/05-async-await/article.md
 ````smart header="`await` 在顶层代码中无效"
 刚开始使用 `await` 的新手往往会忘记这一点，但我们不能在最顶层的代码中编写 `await`，因为它会无效：
+=======
+````smart header="`await` won't work in the top-level code"
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/article.md
 
 ```js run
 // 在顶层代码中导致语法错误
@@ -130,20 +174,45 @@ let response = await fetch('/article/promise-chaining/user.json');
 let user = await response.json();
 ```
 
+<<<<<<< HEAD:6-async/05-async-await/article.md
 所以我们需要将 await 代码封装在一个async 函数中。就像上述例子一样。
 ````
 ````smart header="`await` 接受 thenables"
 像 `promise.then`、`await` 允许使用 thenable 对象（那些具有可调用的 `then` 方法）。同样，我们的想法是，第三方对象可能不是 promise，而是与 promise 兼容：如果它支持 `.then`，那么就可以和 `await` 一起使用。
 
 例如，这里的 `await` 接受 `new Thenable(1)`：
+=======
+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). 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:
+
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/article.md
 ```js run
 class Thenable {
   constructor(num) {
     this.num = num;
   }
   then(resolve, reject) {
+<<<<<<< HEAD:6-async/05-async-await/article.md
     alert(resolve); // function() { native code }
     // 在 1000 ms 后将 this.num*2 作为 resolve 值返回
+=======
+    alert(resolve);
+    // resolve with this.num*2 after 1000ms
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/article.md
     setTimeout(() => resolve(this.num * 2), 1000); // (*)
   }
 };
@@ -160,10 +229,15 @@ f();
 如果 `await` 获取了带有 `.then` 的非 promise 对象，它就会调用提供 `resolve`、`reject` 作为参数的原生函数。`await` 等待，直到其中一个被调用（在上述示例中，发生在 `(*)` 行），然后继续处理结果。
 ````
 
+<<<<<<< HEAD:6-async/05-async-await/article.md
 ````smart header="Async 方法"
 类方法也可以 async，只要把 `async` 放在类方法前即可。
 
 就像这样：
+=======
+````smart header="Async methods"
+To declare an async class method, just prepend it with `async`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/article.md
 
 ```js run
 class Waiter {
@@ -183,7 +257,11 @@ new Waiter()
 ````
 ## Error 处理
 
+<<<<<<< HEAD:6-async/05-async-await/article.md
 如果一个 promise 正常 reslove，那么 `await promise` 就会返回结果。但在 reject 情况下，它会抛出 error，就像该行上有 `throw` 语句一样。
+=======
+If a promise resolves normally, then `await promise` returns the result. But in case of a rejection, it throws the error, just as if there were a `throw` statement at that line.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/article.md
 
 代码：
 
@@ -205,7 +283,11 @@ async function f() {
 }
 ```
 
+<<<<<<< HEAD:6-async/05-async-await/article.md
 在实际情况中，promise 可能需要一段时间才会变成 reject。因此 `await` 会等待，然后抛出 error。
+=======
+In real situations, the promise may take some time before it rejects. So `await` will wait, and then throw an error.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/article.md
 
 我们可以使用 `try..catch` 来捕获这个 error，就像常规 `throw` 方法一样：
 
@@ -254,7 +336,11 @@ f().catch(alert); // 类型错误：未能获取 // (*)
 */!*
 ```
 
+<<<<<<< HEAD:6-async/05-async-await/article.md
 如果忘记在那里添加 `.catch`，那么我们就会得到一个未处理的 promise 错误（可以在控制台中看到）。我们可以像 <info:promise-chaining> 章节所描述的那样，使用一个全局事件处理器来捕获这样的 error。
+=======
+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>.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/article.md
 
 
 ```smart header="`async/await` 和 `promise.then/catch`"
@@ -281,7 +367,39 @@ let results = await Promise.all([
 
 ````
 
+<<<<<<< HEAD:6-async/05-async-await/article.md
 ## 总结
+=======
+## 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
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:1-js/11-async/08-async-await/article.md
 
 函数前的 `async` 关键字有两个作用：
 
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 0000000000..45c8b071bb
--- /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 0000000000..5f3a0ae87e
--- /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 0000000000..8bb5215069
--- /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 0000000000..c2ac531812
--- /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 0000000000..a1675d2fee
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 0000000000..93a53777d9
--- /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 0000000000..d9e891930d
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 0000000000..ef2fcf6b40
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 0000000000..102ec4513f
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 0000000000..8cdf19d086
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 0000000000..7d3d9ace30
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 0000000000..de51a3c947
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 0000000000..f6c1cfb5dd
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 0000000000..74f2f1b912
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 0000000000..1978a864c2
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 0000000000..f26afaf98d
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 0000000000..b32d91eaf5
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 0000000000..42dd4a2db0
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 0000000000..428b4226b4
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 0000000000..fc9f286a4b
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 0000000000..43b214a0fc
--- /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 generated 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 0000000000..74d66a8b8c
--- /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 0000000000..ccc909d1aa
--- /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
index 8535adb50b..edd0c5608a 100755
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -1,4 +1,5 @@
 
+<<<<<<< HEAD
 # 模块 (Modules) 简介
 
 当我们的应用日益增大时，我们想要将应用分割成多个文件，即我们所说的“模块”。
@@ -26,6 +27,35 @@
 - `import` 关键字允许从其他模块中导入一些诸如函数之类的功能等等。
 
 例如，我们有一个名为 `sayHi.js` 的文件导出一个函数：
+=======
+# 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, special libraries to load modules on demand.
+
+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.
+
+There are directives `export` and `import` to interchange functionality between modules, call functions of one module from another one:
+
+- `export` keyword labels variables and functions that should be accessible from outside the current module.
+- `import` allows to import functionality from other modules.
+
+For instance, if we have a file `sayHi.js` exporting a function:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 // 📁 sayHi.js
@@ -34,7 +64,11 @@ export function sayHi(user) {
 }
 ```
 
+<<<<<<< HEAD
 然后在其他的文件里导入并使用它：
+=======
+...Then another file may import and use it:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 // 📁 main.js
@@ -44,6 +78,7 @@ alert(sayHi); // function...
 sayHi('John'); // Hello, John!
 ```
 
+<<<<<<< HEAD
 在这个章节里，我们专注于语言本身，但是我们使用浏览器作为演示环境，那么就让我们开始来看看怎么在浏览器中使用模块的。
 
 由于模块使用特殊的关键词和功能，所以我们必须通过使用属性 `<script type="module">` 来告诉浏览器，脚本应该被当作 `模块` 来看待。
@@ -63,6 +98,27 @@ sayHi('John'); // Hello, John!
 ### 始终使用 "use strict"
 
 模块始终默认使用使用 `use strict`，例如，对一个未声明的变量赋值将会抛出错误。
+=======
+In this tutorial we concentrate on the language itself, but we use browser as the demo environment, so let's see how to use modules in the browser.
+
+As modules support special keywords and features, we must tell the browser that a script should be treated as module, by using the attribute `<script type="module">`.
+
+Like this:
+
+[codetabs src="say" height="140" current="index.html"]
+
+The browser automatically fetches and evaluates imported modules, and 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`, by default. E.g. assigning to an undeclared variable will give an error.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html run
 <script type="module">
@@ -70,6 +126,7 @@ sayHi('John'); // Hello, John!
 </script>
 ```
 
+<<<<<<< HEAD
 在这里我们可以在浏览器里看到它，但是对于任何模块来说都是一样的。
 
 ### 模块级作用域（Module-level scope）
@@ -93,6 +150,31 @@ sayHi('John'); // Hello, John!
 ```html run
 <script type="module">
   // 变量仅可在模块脚本内部可见
+=======
+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, independent top-level scope also exists for each `<script type="module">`:
+
+```html run
+<script type="module">
+  // The variable is only visible in this module script
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
   let user = "John";
 </script>
 
@@ -103,6 +185,7 @@ sayHi('John'); // Hello, John!
 </script>
 ```
 
+<<<<<<< HEAD
 如果我们真的需要创建一个窗口级别（window-level）的全局变量，我们可以显式地将它分配给 `window` 并以 `window.user` 来访问它。但是这样做需要你有足够充分的理由，否则就不要这样。
 
 ### 模块代码仅在第一次导入时解析
@@ -112,6 +195,17 @@ sayHi('John'); // Hello, John!
 这具有很重要的后果。我们来看一下下面的例子：
 
 首先，如果执行一个模块中的代码带来一些副作用，比如显示一个消息，然后多次导入它但是只会显示一次，即第一次：
+=======
+If we really need to make a window-level global 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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 // 📁 alert.js
@@ -119,7 +213,11 @@ alert("Module is evaluated!");
 ```
 
 ```js
+<<<<<<< HEAD
 // 从不同的文件导入相同模块
+=======
+// Import the same module from different files
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 // 📁 1.js
 import `./alert.js`; // Module is evaluated!
@@ -128,11 +226,19 @@ import `./alert.js`; // Module is evaluated!
 import `./alert.js`; // (nothing)
 ```
 
+<<<<<<< HEAD
 在日常开发中，顶级模块主要是用于初始化使用的。我们创建数据结构，预填充它们，如果我们想要可重用某些东西，只要导出即可。
 
 下面是一个高级点的例子：
 
 我们假设一个模块导出了一个对象：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 // 📁 admin.js
@@ -141,9 +247,15 @@ export let admin = {
 };
 ```
 
+<<<<<<< HEAD
 如果这个模块被导入到多个文件中，模块仅仅在第一次导入的时候解析创建 `admin` 对象。然后将其传入所有导入的位置。
 
 所有导入位置都得到了唯一的 `admin` 对象。
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 // 📁 1.js
@@ -155,6 +267,7 @@ import {admin} from './admin.js';
 alert(admin.name); // Pete
 
 *!*
+<<<<<<< HEAD
 // 1.js 和 2.js 导入相同的对象
 // 1.js 中对对象的修改，在 2.js 中是可访问的
 */!*
@@ -165,6 +278,18 @@ alert(admin.name); // Pete
 这种行为对于需要配置的模块来说是非常棒的。我们可以在第一次导入时设置所需要的属性，然后在后面的导入中就可以直接使用了。
 
 例如，下面的 `admin.js` 模块可能提供特定的功能，但是希望在外部可访问 `admin` 对象：
+=======
+// 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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 // 📁 admin.js
@@ -175,7 +300,11 @@ export function sayHi() {
 }
 ```
 
+<<<<<<< HEAD
 现在，在 `init.js`——我们 app 的第一个脚本中，设置了 `admin.name`。现在每个位置都能看到它了，包括来自 `admin.js` 本身的调用。
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 // 📁 init.js
@@ -194,6 +323,7 @@ sayHi(); // Ready to serve, *!*Pete*/!*!
 
 ### import.meta
 
+<<<<<<< HEAD
 `import.meta` 对象包含当前模块的一些信息。
 
 它的内容取决于其所在环境，比如说在浏览器环境中，它包含脚本的链接，如果是在 HTML 中的话就是当前页面的链接。
@@ -209,6 +339,23 @@ sayHi(); // Ready to serve, *!*Pete*/!*!
 这是一个小功能，但为了完整性，我们应该提到它。
 
 在一个模块中，顶级 `this` 是未定义的，而不是像非模块脚本中的全局变量。
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html run height=0
 <script>
@@ -220,6 +367,7 @@ sayHi(); // Ready to serve, *!*Pete*/!*!
 </script>
 ```
 
+<<<<<<< HEAD
 ## 特定于浏览器的功能
 
 与常规脚本相比，拥有 `type="module"` 标识的脚本有几个特定于浏览器的差异。
@@ -238,10 +386,31 @@ sayHi(); // Ready to serve, *!*Pete*/!*!
 它的一个副作用是，模块脚本总是“看见”完全加载的 HTML 页面，包括在它们后面的 HTML 元素。
 
 例如：
+=======
+## 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, they load in parallel with other resources.
+- module scripts wait until the HTML document is fully ready (even if they are tiny and load faster than HTML), and then run.
+- relative order of scripts is maintained: scripts that go first in the document, execute first.
+
+As a side-effect, module scripts always "see" the fully loaded HTML-page, including HTML elements below them.
+
+For instance:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html run
 <script type="module">
 *!*
+<<<<<<< HEAD
   alert(typeof button); // object: 脚本可以‘看见‘’下面的 button
 */!*
   // 当脚本模块延迟时，脚本在整个页面加载完成之后才执行
@@ -254,11 +423,26 @@ sayHi(); // Ready to serve, *!*Pete*/!*!
   alert(typeof button); // Error: button is undefined，脚本不能“看到”下面的元素
 */!*
   // 普通脚本在剩余页面加载完成前就执行了
+=======
+  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>
+
+Compare to regular script below:
+
+<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
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 </script>
 
 <button id="button">Button</button>
 ```
 
+<<<<<<< HEAD
 注意：上面的第二个脚本要先于前一个脚本执行，所以我们先会看到 `undefined`，然后才是 `object`。
 
 这是因为模块脚本被延迟执行了，所以要等到页面加载结束才执行。而普通脚本就没有这个限制了，它会马上执行，所以我们先看到它的输出。
@@ -278,6 +462,27 @@ sayHi(); // Ready to serve, *!*Pete*/!*!
 ```html
 <!-- 所有依赖都获取(analytics.js)脚本，然后运行 -->
 <!-- 不会等待 HTML 文档或者其他 <script> 标签 -->
+=======
+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-page shows up as it loads, and JavaScript modules run after that, so the user may see the page 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 by that.
+
+### 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, independently 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 -->
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 <script *!*async*/!* type="module">
   import {counter} from './analytics.js';
 
@@ -285,6 +490,7 @@ sayHi(); // Ready to serve, *!*Pete*/!*!
 </script>
 ```
 
+<<<<<<< HEAD
 ### 外部脚本
 
 外部脚本相较于其他脚本有两个显著的差异：
@@ -292,10 +498,20 @@ sayHi(); // Ready to serve, *!*Pete*/!*!
 1. 具有相同 `src` 属性值的外部脚本仅运行一次：
     ```html
     <!-- my.js 脚本被加载，但它只运行一次 -->
+=======
+### 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 -->
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
     <script type="module" src="my.js"></script>
     <script type="module" src="my.js"></script>
     ```
 
+<<<<<<< HEAD
 2. 从其他域名获取的外部脚本需要加上 [CORS](mdn:Web/HTTP/CORS) 头。换句话说，如果一个模块脚本是从其他域名获取的，那么它所在的远端服务器必须提供 `Access-Control-Allow-Origin: *`（可能使用加载的域名代替 `*`）响应头以指明当前请求是被允许的。
     ```html
     <!-- another-site.com 必须提供 Access-Control-Allow-Origin -->
@@ -320,6 +536,32 @@ import {sayHi} from 'sayHi'; // Error，“裸”模块
 ### 兼容性，"nomodule"
 
 旧时的浏览器不理解 `type="module"` 值。对于位置类型的脚本会被忽略掉。对于它们来说可以使用 `nomodule` 属性来提供后备：
+=======
+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, `import` must get either a relative or absolute URL. Modules without any path are called "bare" modules. Such modules are not allowed in `import`.
+
+For instance, this `import` is invalid:
+```js
+import {sayHi} from 'sayHi'; // Error, "bare" module
+// the module must have a path, e.g. './sayHi.js' or wherever the module is
+```
+
+Certain environments, like Node.js or bundle tools allow bare modules, without any path, 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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html run
 <script type="module">
@@ -332,6 +574,7 @@ import {sayHi} from 'sayHi'; // Error，“裸”模块
 </script>
 ```
 
+<<<<<<< HEAD
 如果我们使用打包工具，当脚本被打包进一个单一文件（或者几个文件），在这些脚本中，`import/export` 语句被特殊的打包函数处理后替代。因此最终打包好的脚本不包含任何 `import/export` 语句，它也不需要 `type="module"` 属性，我们仅像普通脚本一样使用就好了：
 
 ```html
@@ -377,3 +620,50 @@ import {sayHi} from 'sayHi'; // Error，“裸”模块
 在生产环境中，开发者经常基于性能或者其他原因而使用诸如 [Webpack](https://webpack.js.org) 这类的打包工具。
 
 在下一章里，我们将会看到更多关于模块以及如何导入/导出的例子。
+=======
+If we use bundle tools, then as scripts are bundled together into a single file (or few files), `import/export` statements inside those scripts are replaced by special bundler functions. So the resulting "bundled" script does not contain any `import/export`, it doesn't 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.
+    - To load external scripts from another origin (domain/protocol/port), CORS headers are needed.
+    - 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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 0000000000..8aa122f077
--- /dev/null
+++ b/1-js/13-modules/02-import-export/article.md
@@ -0,0 +1,441 @@
+# 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 only use one of `lib.js` functions 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. 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" keyword is used as an "alias" for the default export, for standalone exports and other scenarios when we need to reference it.
+
+For example, if we already have a function declared, that's how to `export default` it (separately from the definition):
+
+```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 more difficult 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';
+// import {MyUser} won't work, the name must be {User}
+```
+
+For default exports, we always choose the name when importing:
+
+```js
+import User from './user.js'; // works
+import MyUser from './user.js'; // works too
+// could be import Anything..., and it'll be 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, excluding 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"`
+- Import the module (it runs), but do not assign it to a variable:
+  - `import "mod"`
+
+We can put import/export statements at the top or at the bottom of a script, that doesn't matter.
+
+So this is technically fine:
+```js
+sayHi();
+
+// ...
+
+import {sayHi} from './say.js'; // import at the end of the script
+```
+
+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 0000000000..ee8bf0a4c5
--- /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 chapters are called "static".
+
+That's because they are indeed static. The syntax is very strict.
+
+First, we can't dynamically 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 0000000000..80909cf94d
--- /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 0000000000..cff234b7c5
--- /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 0000000000..78fb060e89
--- /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 4d553174f5..0000000000
--- 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 0000000000..552c2a8907
--- /dev/null
+++ b/10-misc/12-mutation-observer/article.md
@@ -0,0 +1,250 @@
+
+# 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, used for text nodes,
+    - `"childList"`: child elements added/removed,
+- `target` -- where the change occurred: 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">Click and <b>edit</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?
+
+We can track something like `contentEditable` and implement "undo/redo" functionality (record mutations and rollback/redo them on demand). There are also cases when `MutationObserver` is good from architectural standpoint.
+
+Let's say we're making a website about programming. Naturally, articles and other materials may contain source code snippets.
+
+An HTML markup of a code snippet looks like this:
+```html
+...
+<pre class="language-javascript"><code>
+  // here's the code
+  let hello = "world";
+</code></pre>
+...
+```
+
+Also we'll use a JavaScript highlighting library on our site, e.g. [Prism.js](https://prismjs.com/). A call to `Prism.highlightElem(pre)` examines the contents of such `pre` elements and adds into them special tags and styles for colored syntax highlighting, similar to what you see in examples here, at this page.
+
+When to run that method? We can do it on `DOMContentLoaded` event, or at the bottom of the page. At that moment we have DOM ready, 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.
+
+**Where and when 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 in the code where we load contents: articles, quizzes, forum posts. Do we need to put the highlighting call everywhere? That's not very convenient, and also easy to forget.
+
+And what if the content is loaded by a third-party module? 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) {
+      // we track only elements, skip other nodes (e.g. 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);
+      }
+
+      // maybe there's a code snippet somewhere in its subtree?
+      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`. Please run the code above first, it will watch and highlight the new content:
+
+```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.
+
+## Additional methods
+
+There's a method to stop observing the node:
+
+- `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();
+```
+
+## 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.
+
+## 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 0000000000..65ab3188a0
--- /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 a84c89c1fd..9b0a18919b 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 @@ JavaScript 语言最初是为 Web 浏览器创建的。此后，它发展成为
 
 平台可以是一个浏览器，一台网络服务器，一台洗衣机或其他**主机**。它们每个都提供特定于平台的功能。JavaScript 规范调用了**主机环境**。
 
+<<<<<<< HEAD
 主机环境提供语言核心以外的平台特定对象和功能。Web 浏览器提供了一种控制网页的手段。Node.JS 提供了服务器端功能，等等。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 以下是浏览器在 JavaScript 中运行时的一个鸟瞰图：
 
diff --git a/2-ui/1-document/01-browser-environment/windowObjects.png b/2-ui/1-document/01-browser-environment/windowObjects.png
index 81803bd09d..5408ecb158 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 e6dae7c3d4..d84b380d57 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 733391d507..4c857028aa 100644
--- a/2-ui/1-document/02-dom-nodes/article.md
+++ b/2-ui/1-document/02-dom-nodes/article.md
@@ -106,7 +106,11 @@ drawHtmlTree(node3, 'div.domtree', 690, 150);
 
 在生成 DOM 时，浏览器会自动处理文档中的错误，关闭标签等等。
 
+<<<<<<< HEAD
 这样的“无效”文档：
+=======
+Such an document with unclosed tags:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html no-beautify
 <p>Hello
@@ -176,7 +180,11 @@ drawHtmlTree(node6, 'div.domtree', 690, 500);
 
 在这里我们看到一个新的树节点类型 —— *comment node*，标记为 `#comment`。
 
+<<<<<<< HEAD
 我们可能会想 —— 为什么要将注释添加到 DOM 中？它不会以任何方式影响视觉表示。但是有一条规则 —— 如果 HTML 中有东西，那么它也必须在 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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 **HTML 中的所有内容甚至注释都成为 DOM 的一部分。**
 
@@ -209,7 +217,11 @@ drawHtmlTree(node6, 'div.domtree', 690, 500);
 
 请注意，开发者工具中的 DOM 结构已经过简化。文本节点仅以文本形式显。根本没有“空白”（只有空格）的文本节点。这其实很好，因为大部分时间我们都对元素节点感兴趣。
 
+<<<<<<< HEAD
 点击左上角的 <span class="devtools" style="background-position:-328px -124px"></span> 按钮可以使用鼠标（或其他指针设备）从网页中选择一个节点并“检查”它（在“元素”选项卡中滚动到该节点）。当我们有一个巨大的 HTML 页面（和相应的巨大 DOM），并希望看到其中的一个特定元素的位置时，这很有用。
+=======
+Clicking the <span class="devtools" style="background-position:-328px -124px"></span> button in the left-upper corner allows to choose a node from the webpage using a mouse (or other pointer devices) and "inspect" it (scroll to it in the Elements tab). This works great when we have a huge HTML page (and corresponding huge DOM) and would like to see the place of a particular element in it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 另一种方法是在网页上右键单击并在上下文菜单中选择“检查”。
 
@@ -225,7 +237,11 @@ drawHtmlTree(node6, 'div.domtree', 690, 500);
 
 ## 与控制台交互
 
+<<<<<<< HEAD
 在我们研究 DOM 时，我们也可能想要使用 JavaScript。就比如：获取一个节点并运行一些代码来修改它，看看它长什么样。这里有一些在元素选项卡和控制台之间传输数据的提示。
+=======
+As we explore the DOM, we also may want to apply JavaScript to it. Like: get a node and run some code to modify it, to see the result. Here are few tips to travel between the Elements tab and the console.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - 在元素标签中选择第一个 `<li>`。
 - 按下 `key:Esc` —— 它将在元素标签下方打开控制台。
diff --git a/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/solution.md b/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/solution.md
index d85ef0d8af..e0e40227e1 100644
--- a/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/solution.md
+++ b/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/solution.md
@@ -1,4 +1,13 @@
+<<<<<<< HEAD
 1. 是的，这是真的。`elem.lastChild` 一直是最后一个元素，它就没有 `nextSibling` ，所有如果存在子节点，这个问题的答案就是正确。
 2. 不，这是错的，因为  `elem.children[0]` 是元素中的第一个子元素。但是或许有非元素的节点在它之前。所以 `previousSibling` 或许是一个文本节点。
 
 请注意，对于这两种情况，如果没有子节点就会出现错误。比如说如果 `elem.lastChild` 是 `null`，我们就访问不到 `elem.lastChild.nextSibling`。
+=======
+1. Yes, true. The element `elem.lastChild` is always the last one, it has no `nextSibling`.
+2. No, wrong, because `elem.children[0]` is the first child *among elements*. But there may exist non-element nodes before it. So `previousSibling` may be a text node. Also, if there are no children, then trying to access `elem.children[0]`
+
+Please note: for both cases if there are no children, then there will be an error.
+
+If there are no children, `elem.lastChild` is `null`, so we can't access `elem.lastChild.nextSibling`. And the collection `elem.children` is empty (like an empty array `[]`).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/2-ui/1-document/03-dom-navigation/article.md b/2-ui/1-document/03-dom-navigation/article.md
index 8953f9494c..5a077cd6b0 100644
--- a/2-ui/1-document/03-dom-navigation/article.md
+++ b/2-ui/1-document/03-dom-navigation/article.md
@@ -7,11 +7,19 @@ libs:
 
 # 遍历 DOM
 
+<<<<<<< HEAD
 DOM 让我们可以对元素和它们其中的内容做任何事，但是首先我们需要获取到对应的 DOM 对象，把这个对象赋予一个变量，然后我们才能修改这个对象。
 
 对 DOM 的所有操作都是从 `document` 对象开始的。从这个对象我们可以到达任何节点。
 
 这里是一张描述对象间链接的图片，通过这些链接我们可以在 DOM 节点之间遍历。
+=======
+The DOM allows us to do anything with elements and their contents, but first we need to reach the corresponding DOM object.
+
+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 for travel between DOM nodes:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ![](dom-links.png)
 
@@ -86,7 +94,11 @@ DOM 让我们可以对元素和它们其中的内容做任何事，但是首先
 </html>
 ```
 
+<<<<<<< HEAD
 ...如果我们要找的是 `<body>` 的子系元素，那我们可以先得到它直系子元素 `<div>`，`<ul>` 以及像 `<li>`（`<ul>` 的子元素）和 `<b>`（`<li>` 的子元素）这样嵌套更深的元素 — 这就是 `<body>` 元素包含的整个子树。
+=======
+...And all descendants of `<body>` are not only direct children `<div>`, `<ul>` but also more deeply nested elements, such as `<li>` (a child of `<ul>`) and `<b>` (a child of `<li>`) -- the entire subtree.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 **`childNodes` 集合提供了对所有子节点包括其中文本节点的访问。**
 
@@ -155,9 +167,15 @@ elem.childNodes[elem.childNodes.length - 1] === elem.lastChild
 ```warn header="DOM 集合是只读的"
 DOM 集合甚至可以说本章中列出的**所有**导航属性都是只读的。
 
+<<<<<<< HEAD
 我们不能通过类似 `childNodes[i] = ...` 的操作来替换一个子节点。
 
 修改子节点需要使用其它的方法，我们将会在下一章中看到它们。
+=======
+We can't replace a child by something else by assigning `childNodes[i] = ...`.
+
+Changing DOM needs other methods. We will see them in the next chapter.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ```warn header="DOM 集合是实时的"
@@ -238,7 +256,16 @@ alert( document.documentElement.parentElement ); // null
 
 换句话说，`documentElement`（对应 `<html>` 标签）是根节点。形式上来讲，它有 `document` 作为它的父节点。但是 `document` 并不是一个元素节点，所以 `parentNode` 返回了 `document` 而 `parentElement` 却没有。
 
+<<<<<<< HEAD
 有时候，当我们要遍历父节点并且在每个遍历的节点调用方法时这很重要，但是 `document` 并没有父元素节点，所以我们要将它排除在外。
+=======
+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>
+}
+```
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ````
 
 让我们修改上面的其中一个例子：用 `children` 来替换 `childNodes`。现在它就只显示元素：
@@ -274,18 +301,32 @@ alert( document.documentElement.parentElement ); // null
 
 Tables 是其中一个很好也是很重要的例子。
 
+<<<<<<< HEAD
 **`<table>`** 元素支持 (除了上面给出的之外) 以下这些属性:
 - `table.rows` — 用于表示表中 `<tr>` 元素的集合。
 - `table.caption/tHead/tFoot` — 用于访问元素 `<caption>`、`<thead>`、`<tfoot>`。
 - `table.tBodies` — `<tbody>` 元素的集合（根据标准该元素数量可以很多）。
+=======
+**The `<table>`** element supports (in addition to the given above) these properties:
+- `table.rows` -- the collection of `<tr>` elements of the table.
+- `table.caption/tHead/tFoot` -- references to elements `<caption>`, `<thead>`, `<tfoot>`.
+- `table.tBodies` -- the collection of `<tbody>` elements (can be many according to the standard).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 **`<thead>`、`<tfoot>`、`<tbody>`** 元素提供了 `rows` 属性：
 - `tbody.rows` — 表内部 `<tr>` 元素的集合。
 
+<<<<<<< HEAD
 **`<tr>`：**
 - `tr.cells` — 在给定 `<tr>` 元素下 `<td>` 和 `<th>` 单元格的集合。
 - `tr.sectionRowIndex` — 在封闭的 `<thead>/<tbody>` 中 `<tr>` 的编号。
 - `tr.rowIndex` — 在表中 `<tr>` 元素的编号。
+=======
+**`<tr>`:**
+- `tr.cells` -- the collection of `<td>` and `<th>` cells inside the given `<tr>`.
+- `tr.sectionRowIndex` -- the position (index) of the given `<tr>` inside the enclosing `<thead>/<tbody>/<tfoot>`.
+- `tr.rowIndex` -- the number of the `<tr>` in the table as a whole (including all table rows).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 **`<td>` 和 `<th>`：**
 - `td.cellIndex` — 在封闭的 `<tr>` 中单元格的编号。
@@ -310,7 +351,11 @@ Tables 是其中一个很好也是很重要的例子。
 
 规范：[tabular data](https://html.spec.whatwg.org/multipage/tables.html)。
 
+<<<<<<< HEAD
 HTML 表单还有其它额外的导航属性。我们稍后会在开始使用表单时看到它们。
+=======
+There are also additional navigation properties for HTML forms. We'll look at them later when we start working with forms.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 # 总结
 
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 f7eef5d1f7..c0e2f69413 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 cf4e220cf8..6634711770 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 25b25b377b..d6b5ddf96a 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 84cd33d4e5..827552f656 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/1-find-elements/solution.md b/2-ui/1-document/04-searching-elements-dom/1-find-elements/solution.md
index 1ec4ebf131..3469d92fc3 100644
--- a/2-ui/1-document/04-searching-elements-dom/1-find-elements/solution.md
+++ b/2-ui/1-document/04-searching-elements-dom/1-find-elements/solution.md
@@ -25,7 +25,7 @@ let form = document.getElementsByName('search')[0]
 document.querySelector('form[name="search"]')
 
 // 5. The first input in that form.
-form.getElementsByTagName('input')
+form.getElementsByTagName('input')[0]
 // or
 form.querySelector('input')
 
diff --git a/2-ui/1-document/04-searching-elements-dom/2-tree-info/solution.md b/2-ui/1-document/04-searching-elements-dom/2-tree-info/solution.md
deleted file mode 100644
index 3daf6d7f69..0000000000
--- a/2-ui/1-document/04-searching-elements-dom/2-tree-info/solution.md
+++ /dev/null
@@ -1,19 +0,0 @@
-我们在 `<li>` 中使用循环：
-
-```js
-for (let li of document.querySelectorAll('li')) {
-  ...
-}
-```
-
-循环时，我们需要获取每个 `li` 的文本下标。我们可以直接从第一个节点开始读取，这就是文本节点：
-
-```js
-for (let li of document.querySelectorAll('li')) {
-  let title = li.firstChild.data;
-
-  // title is the text in <li> before any other nodes
-}
-```
-
-之后我们就可以获取后代 `li.getElementsByTagName('li')` 的数目。
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 c5e52bbe2e..79d7cdc36d 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,27 @@
+<<<<<<< HEAD
 # 搜索： getElement* 和 querySelector*
+=======
+# Searching: getElement*, querySelector*
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 当元素关联较密切时，DOM 导航属性是最好的。万一不是这样该怎么办？如何去获取页面上的任意一个元素？ 
 
+<<<<<<< HEAD
 还有其他的搜索方法。
 ## document.getElementById 或者只使用 id
+=======
+There are additional searching methods for that.
+
+## document.getElementById or just id
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如果元素有 `id` 属性，那么该 `id` 也会有一个同名全局变量。
 
+<<<<<<< HEAD
 我们可以用以下方式来访问元素：
+=======
+We can use it to immediately access the element no matter where it is:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html run
 <div id="*!*elem*/!*">
@@ -24,7 +38,13 @@
 </script>
 ```
 
+<<<<<<< HEAD
 除非我们自己声明同名变量：
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html run untrusted height=0
 <div id="elem"></div>
@@ -32,13 +52,17 @@
 <script>
   let elem = 5;
 
-  alert(elem); // the variable overrides the element
+  alert(elem); // 5
 </script>
 ```
 
+<<<<<<< HEAD
 [在规范中](http://www.whatwg.org/specs/web-apps/current-work/#dom-window-nameditem)描述了这种行为，主要是考虑到兼容性才对它进行了支持。为了帮助我们，浏览器尝试了混合 JS 和 DOM 的命名空间。但这仅仅对简单脚本有效，因为它们可能会产生命名冲突。同时，当我们在 JS 中查看时，因为无法在视图中查看 HTML，所以变量的来源可能会很模糊。
 
 选择特殊的方法，才是最好的选择：`document.getElementById(id)`。
+=======
+The better alternative is to use a special method `document.getElementById(id)`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如：
 
@@ -68,6 +92,7 @@
 `getElementById` 只能在 `document` 对象上调用。它会在整个文档中查找给定的 `id`。
 ```
 
+<<<<<<< HEAD
 ## getElementsBy*
 
 也有其他的方法来搜索节点：
@@ -166,6 +191,11 @@ document.getElementsByTagName('input')[0].value = 5;
 现在将进行重要的内容
 
 `elem.querySelectorAll(css)` 的调用将返回与给定 CSS 选择器匹配 `elem` 中的所有元素。这是最常用和最有力的方法。
+=======
+## querySelectorAll [#querySelectorAll]
+
+By far, the most versatile method, `elem.querySelectorAll(css)` returns all elements inside `elem` matching the given CSS selector.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 我们将查找所有为最后一个子元素的  `<li>` 元素：
 
@@ -195,7 +225,6 @@ document.getElementsByTagName('input')[0].value = 5;
 CSS 选择器的伪类，如 `:hover` 和 `:active` 都是被支持的。例如，`document.querySelectorAll(':hover')` 将会返回指针现在已经结束的集合（按嵌套顺序：从最外层 `<html>` 到嵌套最多的元素）。
 ```
 
-
 ## querySelector [#querySelector]
 
 调用 `elem.querySelector(css)` 后，它会返回给定 CSS 选择器的第一个元素。
@@ -230,9 +259,13 @@ CSS 选择器的伪类，如 `:hover` 和 `:active` 都是被支持的。例如
 
 ## closest
 
+<<<<<<< HEAD
 所有直接在给定元素之上的元素都被称为它的“祖先”。
 
 换句话说，祖先是：父类，父类的父类，它的父类等。祖先们一起组成了从元素到顶端的父类链。
+=======
+*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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `elem.closest(css)` 方法会查找与 CSS 选择器匹配的最接近的祖先。`elem` 自己也会被搜索。
 
@@ -260,14 +293,115 @@ CSS 选择器的伪类，如 `:hover` 和 `:active` 都是被支持的。例如
 </script>
 ```
 
+<<<<<<< HEAD
 ## Live 集合
+=======
+## 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.
+- `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
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 所有的 `"getElementsBy*"` 方法都会返回 **live** 集合。这类集合总是可以反映出文档的当前状态而且在文档变化时，可以自动更新。
 
 下面的实例中，有两个脚本。
 
+<<<<<<< HEAD
 1. 第一个方法创建了对集合 `<div>` 的引用。到目前为止，它的长度是 `1`。
 2. 第二个脚本在浏览器再遇到一个 `<div>` 时，它的长度会变成 `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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html run
 <div>First div</div>
@@ -310,9 +444,13 @@ CSS 选择器的伪类，如 `:hover` 和 `:active` 都是被支持的。例如
 
 现在我们可以很容易地看到不同之处。在文档中出现一个新的 `div` 后，静态集合并没有增加。
 
+<<<<<<< HEAD
 我们在这里使用独立的脚本来说明元素添加是如何影响集合的，但是在此之后的任何 DOM 操作都会影响它们。很快我们就可以看到更多的细节。
 
 ## 总结
+=======
+## Summary
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 有 6 种主要的方法，可以在 DOM 中进行搜素：
 
@@ -327,6 +465,18 @@ CSS 选择器的伪类，如 `:hover` 和 `:active` 都是被支持的。例如
 </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,29 +500,26 @@ CSS 选择器的伪类，如 `:hover` 和 `:active` 都是被支持的。例如
 <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>
 
+<<<<<<< HEAD
 请注意，只有在文档 `document.getElementById(...)` 的上下文中才能调用 `getElementById` 和 `getElementsByName`。但元素中没有  `elem.getElementById(...)` 会报错。
 
 也可以在元素上调用其他方法，例如 `elem.querySelectorAll(...)` 将会在 `elem`（在 DOM 子树中）内部进行搜素。
+=======
+By far the most used are `querySelector` and `querySelectorAll`, but `getElementBy*` can be sporadically helpful or found in the old scripts.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 除此以外：
 
 - `elem.matches(css)` 用于检查 `elem` 与给定的 CSS 选择器是否匹配。
 - `elem.closest(css)` 用于查找与给定 CSS 选择器相匹配的最近的祖先。`elem` 本身也会被检查。
 
+<<<<<<< HEAD
 最后我们在提一种检查父子关系的方法：
 -  如果 `elemB` 在 `elemA`（`elemA` 的后代）中或者当 `elemA==elemB` 时 `elemA.contains(elemB)` 将返回 true。
+=======
+And let's mention one more method here to check for the child-parent relationship, as it's sometimes useful:
+-  `elemA.contains(elemB)` returns true if `elemB` is inside `elemA` (a descendant of `elemA`) or when `elemA==elemB`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/2-ui/1-document/05-basic-dom-node-properties/2-tree-info/solution.md b/2-ui/1-document/05-basic-dom-node-properties/2-tree-info/solution.md
new file mode 100644
index 0000000000..90649b05bd
--- /dev/null
+++ b/2-ui/1-document/05-basic-dom-node-properties/2-tree-info/solution.md
@@ -0,0 +1,29 @@
+我们在 `<li>` 中使用循环：
+
+```js
+for (let li of document.querySelectorAll('li')) {
+  ...
+}
+```
+
+<<<<<<< HEAD:2-ui/1-document/04-searching-elements-dom/2-tree-info/solution.md
+循环时，我们需要获取每个 `li` 的文本下标。我们可以直接从第一个节点开始读取，这就是文本节点：
+=======
+In the loop we need to get the text inside every `li`.
+
+We can read the text from the first child node of `li`, that is the text node:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/1-document/05-basic-dom-node-properties/2-tree-info/solution.md
+
+```js
+for (let li of document.querySelectorAll('li')) {
+  let title = li.firstChild.data;
+
+  // title is the text in <li> before any other nodes
+}
+```
+
+<<<<<<< HEAD:2-ui/1-document/04-searching-elements-dom/2-tree-info/solution.md
+之后我们就可以获取后代 `li.getElementsByTagName('li')` 的数目。
+=======
+Then we can get the number of descendants as `li.getElementsByTagName('li').length`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/1-document/05-basic-dom-node-properties/2-tree-info/solution.md
diff --git a/2-ui/1-document/04-searching-elements-dom/2-tree-info/solution.view/index.html b/2-ui/1-document/05-basic-dom-node-properties/2-tree-info/solution.view/index.html
similarity index 100%
rename from 2-ui/1-document/04-searching-elements-dom/2-tree-info/solution.view/index.html
rename to 2-ui/1-document/05-basic-dom-node-properties/2-tree-info/solution.view/index.html
diff --git a/2-ui/1-document/04-searching-elements-dom/2-tree-info/source.view/index.html b/2-ui/1-document/05-basic-dom-node-properties/2-tree-info/source.view/index.html
similarity index 100%
rename from 2-ui/1-document/04-searching-elements-dom/2-tree-info/source.view/index.html
rename to 2-ui/1-document/05-basic-dom-node-properties/2-tree-info/source.view/index.html
diff --git a/2-ui/1-document/04-searching-elements-dom/2-tree-info/task.md b/2-ui/1-document/05-basic-dom-node-properties/2-tree-info/task.md
similarity index 100%
rename from 2-ui/1-document/04-searching-elements-dom/2-tree-info/task.md
rename to 2-ui/1-document/05-basic-dom-node-properties/2-tree-info/task.md
diff --git a/2-ui/1-document/05-basic-dom-node-properties/3-tag-in-comment/solution.md b/2-ui/1-document/05-basic-dom-node-properties/3-tag-in-comment/solution.md
index 19054430b6..01992c0774 100644
--- a/2-ui/1-document/05-basic-dom-node-properties/3-tag-in-comment/solution.md
+++ b/2-ui/1-document/05-basic-dom-node-properties/3-tag-in-comment/solution.md
@@ -12,6 +12,12 @@
 
 这几步都发生了什么：
 
+<<<<<<< HEAD
 1. `<body>` 内容被注释所取代 <code>&lt;!--BODY--&gt;</code>，因为 `body.tagName == "BODY"`。正如我们所记住的，`tagName` 在 HTML 中总是大写的。
 2. 这个注释现在是唯一的子节点，所以我们可以在 `body.firstChild` 中获取。
 3. 注释的`data` 属性是它的内容 (inside `<!--...-->`)：`"BODY"`。
+=======
+1. The content of `<body>` is replaced with the comment. The comment is `<!--BODY-->`, because `body.tagName == "BODY"`. As we remember, `tagName` is always uppercase in HTML.
+2. The comment is now the only child node, so we get it in `body.firstChild`.
+3. The `data` property of the comment is its contents (inside `<!--...-->`): `"BODY"`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/2-ui/1-document/05-basic-dom-node-properties/4-where-document-in-hierarchy/solution.md b/2-ui/1-document/05-basic-dom-node-properties/4-where-document-in-hierarchy/solution.md
index 9f030ec6bb..d5c904cc06 100644
--- a/2-ui/1-document/05-basic-dom-node-properties/4-where-document-in-hierarchy/solution.md
+++ b/2-ui/1-document/05-basic-dom-node-properties/4-where-document-in-hierarchy/solution.md
@@ -27,7 +27,11 @@ alert(document.constructor.name); // HTMLDocument
 alert(HTMLDocument.prototype.constructor === HTMLDocument); // true
 ```
 
+<<<<<<< HEAD
 对于所有原型中的内置类，有一个 `constructor` 引用，我们可以获取 `constructor.name` 来查看类名。我们为 `document` 原型链中的所有对象执行以下操作：
+=======
+To get a name of the class as a string, we can use `constructor.name`. Let's do it for the whole `document` prototype chain, till class `Node`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 alert(HTMLDocument.prototype.constructor.name); // HTMLDocument
diff --git a/2-ui/1-document/05-basic-dom-node-properties/article.md b/2-ui/1-document/05-basic-dom-node-properties/article.md
index 6d1423c6a3..183bcb652e 100644
--- a/2-ui/1-document/05-basic-dom-node-properties/article.md
+++ b/2-ui/1-document/05-basic-dom-node-properties/article.md
@@ -18,6 +18,7 @@ DOM 节点因为它们的类而具有不同的属性。例如，标记 `<a>` 相
 
 类如下所示：
 
+<<<<<<< HEAD
 - [EventTarget](https://dom.spec.whatwg.org/#eventtarget) —— 是根的“抽象”类。该类的对象从未被创建。它作为一个基础，为了让所有 DOM 节点都支持所谓的“事件”，我们会在之后对它进行学习。
 - [Node](http://dom.spec.whatwg.org/#interface-node) —— 也是一个“抽象”类，充当 DOM 节点的基础。它提供了树的核心功能：`parentNode`、`nextSibling`、`childNodes` 等（它们都是 getter）。`Node` 类的对象从未被创建。但是一些具体的节点类却继承自它，例如：`Text` 表示文本节点，`Element` 用于元素节点，以及更多外来的类（如注释节点 `Comment`）。
 - [Element](http://dom.spec.whatwg.org/#interface-element) —— 是 DOM 元素的基类。它提供了元素级的导航，比如 `nextElementSibling`、`children` 以及像 `getElementsByTagName`、`querySelector` 这样的搜索方法。浏览器中不仅有 HTML，还会有 XML 和SVG 文档。`Element` 类充当以下更具体类的基类：`SVGElement`、`XMLElement` 和 `HTMLElement`。
@@ -26,6 +27,16 @@ DOM 节点因为它们的类而具有不同的属性。例如，标记 `<a>` 相
     - [HTMLBodyElement](https://html.spec.whatwg.org/multipage/semantics.html#htmlbodyelement) —— `<body>` 元素的类，
     - [HTMLAnchorElement](https://html.spec.whatwg.org/multipage/semantics.html#htmlanchorelement) ——  `<a>` 元素的类，
     - 等等，每个标记都有可以为自己提供特定属性和方法的类。
+=======
+- [EventTarget](https://dom.spec.whatwg.org/#eventtarget) -- is the root "abstract" class. Objects of that class are never created. It serves as a base, so that all DOM nodes support so-called "events", we'll study them later.
+- [Node](http://dom.spec.whatwg.org/#interface-node) -- is also an "abstract" class, serving as a base  for DOM nodes. It provides the core tree functionality: `parentNode`, `nextSibling`, `childNodes` and so on (they are getters). Objects of `Node` class are never created. But there are concrete node classes that inherit from it, namely: `Text` for text nodes, `Element` for element nodes and more exotic ones like `Comment` for comment nodes.
+- [Element](http://dom.spec.whatwg.org/#interface-element) -- is a base class for DOM elements. It provides element-level navigation like `nextElementSibling`, `children` and searching methods like `getElementsByTagName`, `querySelector`. A  browser supports not only HTML, but also XML and SVG. The `Element` class serves as a base for more specific classes: `SVGElement`, `XMLElement` and `HTMLElement`.
+- [HTMLElement](https://html.spec.whatwg.org/multipage/dom.html#htmlelement) -- is finally the basic class for all HTML elements. It is inherited by various HTML elements:
+    - [HTMLInputElement](https://html.spec.whatwg.org/multipage/forms.html#htmlinputelement) -- the class for `<input>` elements,
+    - [HTMLBodyElement](https://html.spec.whatwg.org/multipage/semantics.html#htmlbodyelement) -- the class for `<body>` elements,
+    - [HTMLAnchorElement](https://html.spec.whatwg.org/multipage/semantics.html#htmlanchorelement) -- the class for `<a>` elements
+    - ...and so on, each tag has its own class that may provide specific properties and methods.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 因此，给定节点的全部属性和方法都是继承的结果。
 
@@ -76,7 +87,11 @@ alert( document.body instanceof EventTarget ); // true
 ```
 
 ````smart header="IDL in the spec"
+<<<<<<< HEAD
 在规范中，类不是用 JavaScript 描述的，而是一个特殊的[接口描述语言（IDL）](https://en.wikipedia.org/wiki/Interface_description_language)，它很容易理解。
+=======
+In the specification, DOM classes are described not using JavaScript, but a special [Interface description language](https://en.wikipedia.org/wiki/Interface_description_language) (IDL), that is usually easy to understand.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在 IDL 中，所有的属性都有它们的类型。比如，`DOMString` 和 `boolean` 等等。
 
@@ -91,7 +106,11 @@ interface HTMLInputElement: HTMLElement {
   // 下面是 <input> 元素的属性和方法
 
 *!*
+<<<<<<< HEAD
   // "DOMString" 意思是这些属性都是字符串
+=======
+  // "DOMString" means that the value of these properties are strings
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 */!*
   attribute DOMString accept;
   attribute DOMString alt;
@@ -99,12 +118,20 @@ interface HTMLInputElement: HTMLElement {
   attribute DOMString value;
 
 *!*
+<<<<<<< HEAD
   // 布尔属性（true/false）
+=======
+  // boolean value property (true/false)
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
   attribute boolean autofocus;
 */!*
   ...
 *!*
+<<<<<<< HEAD
   //方法 "void" 意思是无返回值
+=======
+  // now the method: "void" means that the method returns no value
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 */!*
   void select();
   ...
@@ -156,7 +183,11 @@ alert( document.body.nodeName ); // BODY
 alert( document.body.tagName ); // BODY
 ```
 
+<<<<<<< HEAD
 tagName 和 nodeName 之间有何不同？
+=======
+Is there any difference between `tagName` and `nodeName`?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 当然，差异反映在它们的名字上，但是确实有些微妙。
 
@@ -175,11 +206,11 @@ tagName 和 nodeName 之间有何不同？
 
   <script>
     // for comment
-    alert( document.body.firstChild.tagName ); // undefined (no element)
+    alert( document.body.firstChild.tagName ); // undefined (not an element)
     alert( document.body.firstChild.nodeName ); // #comment
 
     // for document
-    alert( document.tagName ); // undefined (not element)
+    alert( document.tagName ); // undefined (not an element)
     alert( document.nodeName ); // #document
   </script>
 </body>
@@ -232,14 +263,22 @@ tagName 和 nodeName 之间有何不同？
 ```
 
 ```smart header="Scripts don't execute"
+<<<<<<< HEAD
 如果 `innerHTML` 将 `<script>` 标签插入到 document 中 —— 它不会被执行。
 
 它会被变成 HTML 的一部分，就像已经运行的脚本一样。
+=======
+If `innerHTML` inserts a `<script>` tag into the document -- it becomes a part of HTML, but doesn't execute.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ### 小心："innerHTML+=" 会完全重写
 
+<<<<<<< HEAD
 我们可以通过使用 `elem.innerHTML+="something"` 来添加“更多的 HTML”。
+=======
+We can append HTML to an element by using `elem.innerHTML+="more html"`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 就像这样：
 
@@ -327,7 +366,11 @@ elem.innerHTML = elem.innerHTML + "..."
 
 其他节点类型具有它们的对应项：`nodeValue` 和 `data` 属性。这两个在实际开发中作用几乎相同，只有细微的差异。所以我们使用 `data`，因为它更短。
 
+<<<<<<< HEAD
 我们可以像这样读它：
+=======
+An example of reading the content of a text node and a comment:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html run height="50"
 <body>
@@ -347,7 +390,11 @@ elem.innerHTML = elem.innerHTML + "..."
 </body>
 ```
 
+<<<<<<< HEAD
 对于文本节点，我们可以想象一个读取或修改它们的理由，但是为什么是注释呢？通常它们一点都不有趣，但有时开发者会将信息嵌入到 HTML 中，如下所示：
+=======
+For text nodes we can imagine a reason to read or modify them, but why comments? Usually, they are not interesting at all, but sometimes developers embed information or template instructions into HTML in them, like this:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html
 <!-- if isAdmin -->
@@ -470,7 +517,11 @@ DOM 元素还具有其他属性，其中许多属性由类提供：
 DOM 节点的属性主要有：
 
 `nodeType`
+<<<<<<< HEAD
 : 我们可以从 DOM 对象类中获取 `nodeType`，但我们通常只需要查看它是文本节点还是元素节点。`nodeType` 属性就可以我们的需求。它有数值，最重要的是：`1` —— 是元素，`3` —— 是文本。只读。
+=======
+: We can use it to see if a node is a text or an element node. It has a numeric value: `1` -- for elements,`3` -- for text nodes, and few other for other node types. Read-only.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `nodeName/tagName`
 : 对于元素来说，标记名（除了 XML 模式外都要大写）。对于非元素节点，`nodeName` 则描述了它是什么。只读。
@@ -485,11 +536,19 @@ DOM 节点的属性主要有：
 : 非元素节点（文本、注释）内容。两者几乎一样，我们通常使用 `data`。允许被修改。
 
 `textContent`
+<<<<<<< HEAD
 : 元素中的文本，基本上是 HTML 减去所有 `<tags>`。将文本写入元素中，并把所有特殊字符和标记完全视为文本。可以安全地插入用户生成的文本，防止不必要的 HTML 插入。
+=======
+: The text inside the element: HTML minus all `<tags>`. Writing into it puts the text inside the element, with all special characters and tags treated exactly as text. Can safely insert user-generated text and protect from unwanted HTML insertions.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `hidden`
 : 当设置为 `true` 时，执行与 CSS `display:none` 相同的操作。
 
 DOM 节点还具有其他属性，具体内容则取决于它们的类。例如，`<input>`元素（`HTMLInputElement`）支持 `value`、`type`，而 `<a>` 元素（`HTMLAnchorElement`）则支持 `href` 等。大多数标准 HTML 属性都具有相应的 DOM 属性。
 
+<<<<<<< HEAD
 但是 HTML 属性和 DOM 属性并不总是一致的，我们会在下一章中看到这点。
+=======
+Although, HTML attributes and DOM properties are not always the same, as we'll see in the next chapter.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 e48064cce4..d82e903760 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 343f4890d5..8a5ce5c0b7 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 f3626fb210..a4655d938f 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
@@ -6,9 +6,15 @@ importance: 3
 
 改变所有外来链接的 `style` 属性，使链接变橙色。
 
+<<<<<<< HEAD
 如果一个链接是外来的：
 - 这个 `href` 包含有 `://`
 - 但不是以 `http://internal.com` 开头。
+=======
+A link is external if:
+- Its `href` has `://` in it
+- But doesn't start with `http://internal.com`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如：
 
diff --git a/2-ui/1-document/06-dom-attributes-and-properties/article.md b/2-ui/1-document/06-dom-attributes-and-properties/article.md
index 3430a2205b..5a6eaf313e 100644
--- a/2-ui/1-document/06-dom-attributes-and-properties/article.md
+++ b/2-ui/1-document/06-dom-attributes-and-properties/article.md
@@ -1,6 +1,10 @@
 # 特性和属性
 
+<<<<<<< HEAD
 > 译注：原文标题为“Attributes and properties”。两词意思相近，为作区分，将 Attribute 译为“特性”，Property 译为“属性”。
+=======
+When the browser loads the page, it "reads" (another word: "parses") the HTML and generates DOM objects from it. For element nodes, most standard HTML attributes automatically become properties of DOM objects.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 当浏览器加载页面时，它会“读取”（或者称之为：“解析”）HTML 文本并生成 DOM 对象。对于元素节点，大多数 HTML 特性会自动变成 DOM 对象的属性。
 
@@ -53,7 +57,11 @@ document.body.sayHi(); // Hello, I'm BODY
 
 ## HTML 特性
 
+<<<<<<< HEAD
 在 HTML 语言中，标签可能拥有特性。当浏览器读取 HTML 文本并根据标签生成 DOM 对象，它会辨别**标准化**特性然后以此创建 DOM 属性。
+=======
+In HTML, tags may have attributes. When the browser parses the HTML to create DOM objects for tags, it recognizes *standard* attributes and creates DOM properties from them.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 因此当一个元素有 `id` 或其他**标准化**特性，会生相应的 DOM 属性。但是非**标准化**的特性则会被忽略。
 
@@ -85,9 +93,15 @@ document.body.sayHi(); // Hello, I'm BODY
 </body>
 ```
 
+<<<<<<< HEAD
 如果一个特性不是标准化的，DOM 属性就不存在这个特性。那我们有没办法获取到这个特性？
 
 答案是肯定的。以下几个方法是针对元素特性的操作：
+=======
+So, if an attribute is non-standard, there won't be a DOM-property for it. Is there a way to access such attributes?
+
+Sure. All attributes are accessible by using the following methods:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - `elem.hasAttribute(name)` —— 检验是否拥这个特性。
 - `elem.getAttribute(name)` —— 获取到这个特性值。
@@ -137,10 +151,17 @@ HTML 特性有几个特征：
 
 请注意：
 
+<<<<<<< HEAD
 1. `getAttribute('About')` —— 这里的第一个字母是大写的，但是在 HTML 里是全小写表示。这也就说明：特性的键名是大小写不敏感的。
 2. 我们可以赋予它任何值，这里我们把 `"123"` 作为它的值。
 3. 所有特性都有一个 `outerHTML` 给我们设置它在页面上的展示内容。
 4. `attributes` 以 `name` 和 `value` 这样的键—值对收集在一个可迭代对象里。
+=======
+1. `getAttribute('About')` -- the first letter is uppercase here, and in HTML it's all lowercase. But that doesn't matter: attribute names are case-insensitive.
+2. We can assign anything to an attribute, but it becomes a string. So here we have `"123"` as the value.
+3. All attributes including ones that we set are visible in `outerHTML`.
+4. The `attributes` collection is iterable and has all the attributes of the element (standard and non-standard) as objects with `name` and `value` properties.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 属性—特性的同步
 
@@ -188,7 +209,11 @@ HTML 特性有几个特征：
 - 改变特性值 `value` 会更新到属性上。
 - 但是直接改变属性的值却不会作用在特性的值上。
 
+<<<<<<< HEAD
 这种“特征”是相当便利的，因为用户可能会经常修改 `value`，假设我们想要覆盖 HTML上“原始值”，只需要修改特性的值。
+=======
+That "feature" may actually come in handy, because the user actions may lead to `value` changes, and then after them, if we want to recover the "original" value from HTML, it's in the attribute.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## DOM 属性的类型
 
@@ -218,9 +243,15 @@ DOM 并不总是字符串。例如 `input.checked` 属性（多选框）是一
 </script>
 ```
 
+<<<<<<< HEAD
 还有一个非常重要的不同点。DOM 属性的字符串可能跟特性值的字符串所表示的不是同一个东西！
 
 例如 `href` DOM 属性总是一个绝对路径的，而特性值只包含相对路径或者只包含 `#hash` 这一部分。
+=======
+Most properties are strings though.
+
+Quite rarely, even if a DOM property type is a string, it may differ from the attribute. For instance, the `href` DOM property is always a *full* URL, even if the attribute contains a relative URL or just a `#hash`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这里有一个例子：
 
@@ -382,7 +413,11 @@ div.setAttribute('order-state', 'canceled');
 - `elem.removeAttribute(name)` —— 移除这个特性
 - `elem.attributes` —— 所有特性的集合
 
+<<<<<<< HEAD
 对于大多数需求，DOM 属性已经可以给予很好的支持。应当在 DOM 属性实在无法满足开发需求的情况下才使用特性，比如以下情况：
+=======
+For most situations using DOM properties is preferable. We should refer to attributes only when DOM properties do not suit us, when we need exactly attributes, for instance:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - 我们需要一个非标准化的特性。但是如果我们用 `data-` 来设置特性值，那就要使用 `dataset` 来获取属性值。
 - 我们想要读取到 HTML 的展示内容。比如 `href` 属性总是一个绝对路径，但是我们只想要相对路径。
diff --git a/2-ui/1-document/07-modifying-document/1-createtextnode-vs-innerhtml/solution.md b/2-ui/1-document/07-modifying-document/1-createtextnode-vs-innerhtml/solution.md
index 7476de912f..fa8f53060a 100644
--- a/2-ui/1-document/07-modifying-document/1-createtextnode-vs-innerhtml/solution.md
+++ b/2-ui/1-document/07-modifying-document/1-createtextnode-vs-innerhtml/solution.md
@@ -12,7 +12,7 @@
   let text = '<b>text</b>';
 
   elem1.append(document.createTextNode(text));
-  elem2.textContent = text;
-  elem3.innerHTML = text;
+  elem2.innerHTML = text;
+  elem3.textContent = text;
 </script>
 ```
diff --git a/2-ui/1-document/07-modifying-document/10-clock-setinterval/solution.view/index.html b/2-ui/1-document/07-modifying-document/10-clock-setinterval/solution.view/index.html
index 5c0319b620..1bf642b102 100644
--- a/2-ui/1-document/07-modifying-document/10-clock-setinterval/solution.view/index.html
+++ b/2-ui/1-document/07-modifying-document/10-clock-setinterval/solution.view/index.html
@@ -54,5 +54,11 @@
     clockStart();
   </script>
 
+  <!-- click on this button calls clockStart() -->
+  <input type="button" onclick="clockStart()" value="Start">
+
+  <!-- click on this button calls clockStop() -->
+  <input type="button" onclick="clockStop()" value="Stop">
+
 </body>
 </html>
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 c2f1d5f3c1..823e8338d6 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
@@ -7,3 +7,5 @@ importance: 4
 创建一个彩色时钟：
 
 [iframe src="solution" height=60]
+
+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 9ba40a6d04..fd85e6c760 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 86248d20e8..c6a1980e4e 100644
--- a/2-ui/1-document/07-modifying-document/article.md
+++ b/2-ui/1-document/07-modifying-document/article.md
@@ -61,7 +61,11 @@ div.className = "alert alert-success";
 div.innerHTML = "<strong>Hi there!</strong> You've read an important message.";
 ```
 
+<<<<<<< HEAD
 之后，我们就有拥有一个 DOM 元素。现在这个元素已经有一个保存类名的变量和一个保存文字信息的变量，但是在页面上依然看不到我们想要的内容，因为它还没有被插入到页面中。
+=======
+After that, we have our DOM element ready. Right now it is just in a variable and we cannot see it. That is because it's not yet inserted into the page.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 插值方法
 
@@ -135,8 +139,13 @@ div.innerHTML = "<strong>Hi there!</strong> You've read an important message.";
     */!*
     </script>
     ```
+<<<<<<< HEAD
     如果需要把 `newLi` 插入成为第一个子元素，我们可以这样做：
     
+=======
+    To insert `newLi` as the first element, we can do it like this:
+
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
     ```js
     list.insertBefore(newLi, list.firstChild);
     ```
@@ -236,7 +245,11 @@ after
 
 接下来登场的这个方法就可以做到：`elem.insertAdjacentHTML(where, html)`。
 
+<<<<<<< HEAD
 该方法第一个参数是字符串，指定插值的位置，必须是以下四个值之一：
+=======
+The first parameter is a string, specifying where to insert. Must be one of the following:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - `"beforebegin"` —— 在 `html` 开头位置前插入 `elem`，
 - `"afterbegin"` —— 在 `html` 开头位置后插入 `elem`，
@@ -273,10 +286,17 @@ after
 
 这个方法还有两个变种：
 
+<<<<<<< HEAD
 - `elem.insertAdjacentText(where, text)` —— 一样的语法，只不过把 `text` 作为“文本”直接插入到 HTML 中，
 - `elem.insertAdjacentElement(where, elem)` —— 一样的语法，只不过插入的是一个元素。
 
 他们存在的意义更多是为了使语法“整齐划一”，在实践中，通常只使用 `insertAdjacentHTML`，因为插入文本和元素的方法可以使用 `append/prepend/before/after` —— 同样的效果这样写起来更简洁。
+=======
+- `elem.insertAdjacentText(where, text)` -- the same syntax, but a string of `text` is inserted "as text" instead of HTML,
+- `elem.insertAdjacentElement(where, elem)` -- the same syntax, but inserts an element.
+
+They exist mainly to make the syntax "uniform". In practice, only `insertAdjacentHTML` is used most of the time. Because for elements and text, we have methods `append/prepend/before/after` -- they are shorter to write and can insert nodes/text pieces.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这里有一个展示一条信息的变种写法：
 
@@ -335,13 +355,89 @@ after
 </script>
 ```
 
+<<<<<<< HEAD
 ## 移除
+=======
+
+## 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
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 想要移除节点，可以通过以下方法：
 
 
 `parentElem.removeChild(node)`
+<<<<<<< HEAD
 : 从 `parentElem` 中移除 `elem`（假设它是元素中的子元素）。
+=======
+: Removes `node` from  `parentElem` (assuming it's a child).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `node.remove()`
 : 从当前位置移除 `node`。
@@ -409,7 +505,11 @@ after
 
 调动 `document.write(html)` 时意味着将 `html` “就地并马上”放入到页面中。`html` 字符串会动态的创建，所以它以自动伸缩的方式放入到页面中。我们可以通过 JavaScript 创建一个完整的 HTML 页面并写入浏览器窗口中。
 
+<<<<<<< HEAD
 这个方法的起源于没有 DOM，没有 Web 标准的上古时期……，但是这个方法依旧保留了下来，因为很多的脚本使用它来实现一些功能。
+=======
+The method comes from times when there was no DOM, no standards... Really old times. It still lives, because there are scripts using it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 现代的脚本已经很少再看到这个方法，因为使用它有一个很重要的局限性：
 
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 5bff84d850..858056f72e 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 44c369ee66..9d68943147 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 08063bc517..7cf2f5973c 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 60333ad1bb..fcb14017ae 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/2-create-notification/task.md b/2-ui/1-document/08-styles-and-classes/2-create-notification/task.md
index ccc7a01dbf..1aabc6769c 100644
--- a/2-ui/1-document/08-styles-and-classes/2-create-notification/task.md
+++ b/2-ui/1-document/08-styles-and-classes/2-create-notification/task.md
@@ -4,7 +4,11 @@ importance: 5
 
 # 创建通知
 
+<<<<<<< HEAD
 编写 `showNotification(options)` 通知函数：`<div class="notification">` 包含给定内容。通知应该在 1.5 秒后自动消失。
+=======
+Write a function `showNotification(options)` that creates a notification: `<div class="notification">` with the given content. The notification should automatically disappear after 1.5 seconds.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 参数：
 
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 ee8d93109b..4f7ff57394 100644
--- a/2-ui/1-document/08-styles-and-classes/article.md
+++ b/2-ui/1-document/08-styles-and-classes/article.md
@@ -1,6 +1,10 @@
 # 样式和类
 
+<<<<<<< HEAD
 在我们讨论 JavaScript 处理样式和类的方法之前 —— 有一个重要的规则。尽管这足够明显的，但我们还是要提到这一点。
+=======
+Before we get into JavaScript's ways of dealing with styles and classes -- here's an important rule. Hopefully it's obvious enough, but we still have to mention it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 通常有两种方式来设计元素样式：
 
@@ -116,7 +120,11 @@ button.style.WebkitBorderRadius = '5px';
 
 例如，为了隐藏一个元素，我们可以设置 `elem.style.display = "none"`。
 
+<<<<<<< HEAD
 然后，我们可能要移除 `style.display`，就像它没有被设置一样。这里不应该使用 `delete elem.style.display`，而应该使用 `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 = ""`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 // if we run this code, the <body> "blinks"
@@ -125,7 +133,11 @@ document.body.style.display = "none"; // hide
 setTimeout(() => document.body.style.display = "", 1000); // 恢复正常
 ```
 
+<<<<<<< HEAD
 如果我们设置 `display` 为空字符串，那么浏览器一般会应用 CSS 类以及内置样式，就像根本没有这样的 `style` 属性。
+=======
+If we set `display` to an empty string, then the browser applies CSS classes and its built-in styles normally, as if there were no such `display` property at all.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ````smart header="用 `style.cssText` 进行重写"
 通常，我们使用 `style.*` 来分配单独的样式属性。我们不能将完整的样式设置为 `div.style="color: red; width: 100px"`，因为 `div.style` 是一个对象，而且它是只读的。
@@ -147,7 +159,11 @@ setTimeout(() => document.body.style.display = "", 1000); // 恢复正常
 </script>
 ```
 
+<<<<<<< HEAD
 我们很少使用它，因为这样的赋值会删除所有现有样式：它不会添加，而是替换它们。偶尔会移出所需的东西。但是当我们知道我们不移出一些重要的内容时，仍然可以对新元素进行处理。
+=======
+We rarely use it, because such assignment removes all existing styles: it does not add, but replaces them. May occasionally delete something needed. But still can be done for new elements when we know we won't delete something important.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 通过设置属性：`div.setAttribute('style', 'color: red...')` 也可以实现同样的目的。
 ````
@@ -207,7 +223,11 @@ setTimeout(() => document.body.style.display = "", 1000); // 恢复正常
 </body>
 ```
 
+<<<<<<< HEAD
 ...但如果我们需要，比如说，把边距增加 20px 呢？那么需要当前值作为开始。
+=======
+...But what if we need, say, to increase the margin by 20px? We would want the current value of it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 还有另一种方法：`getComputedStyle`。
 
@@ -281,7 +301,11 @@ pseudo
 
 但 `getComputedStyle` 不允许访问该颜色，否则任意页面都可以通过在页面上创建连接并通过检查样式来确定用户是否访问了连接。
 
+<<<<<<< HEAD
 JavaScript 中我们看不到 `:visited` 应用的样式。此外，CSS 中也有一个限制，禁止在 `:visited` 中应用更改几何的样式。这是为了保证一个不好的页面没有办法来测试是否访问了链接，从而窥探隐私。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ## 总结
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 098f9eb6d5..67b9019a04 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 3ecb293753..fe58f35427 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/6-width-vs-clientwidth/solution.md b/2-ui/1-document/09-size-and-scroll/6-width-vs-clientwidth/solution.md
index 2e3860fc85..ec937113e9 100644
--- a/2-ui/1-document/09-size-and-scroll/6-width-vs-clientwidth/solution.md
+++ b/2-ui/1-document/09-size-and-scroll/6-width-vs-clientwidth/solution.md
@@ -1,6 +1,13 @@
 不同点：
 
+<<<<<<< HEAD
 1. `clientWidth` 值是数值，然而 `getComputedStyle(elem).width` 返回一个包含 `px` 的字符串。
 2. `getComputedStyle` 可能返回非数值的结果，例如内联元素的 `"auto"`。
 3. `clientWidth` 是元素的内部内容区域加上内间距，而 CSS 宽度（具有标准的 `box-sizing`）是内部**不包括内间距**的空间区域。
 4. 如果有一个滚动条，一般浏览器保留它的空间，有的浏览器从 CSS 宽度中减去这个空间（因为它不再用于内容），而有些则不这样做。`clientWidth` 属性总是相同的：如果保留了滚动条，那么它的宽度将被删去。
+=======
+1. `clientWidth` is numeric, while `getComputedStyle(elem).width` returns a string with `px` at the end.
+2. `getComputedStyle` may return non-numeric width like `"auto"` for an inline element.
+3. `clientWidth` is the inner content area of the element plus paddings, while CSS width (with standard `box-sizing`) is the inner content area *without paddings*.
+4. If there's a scrollbar and the browser reserves the space for it, some browser substract that space from CSS width (cause it's not available for content any more), and some do not. The `clientWidth` property is always the same: scrollbar size is substracted if reserved.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
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 79683bbbba..0d861a3c3b 100644
--- a/2-ui/1-document/09-size-and-scroll/article.md
+++ b/2-ui/1-document/09-size-and-scroll/article.md
@@ -60,6 +60,7 @@ JavaScript 中存在许多属性让我们能够读取元素的宽度、高度或
 
  `offsetParent` 是最近的祖先元素:
 
+<<<<<<< HEAD
 1. CSS 定位（`position` 为 `absolute`、`relative` 或 `fixed`），
 2. 或者 `<td>`、`<th>`、`<table>`，
 3. 或者 `<body>`。
@@ -67,6 +68,15 @@ JavaScript 中存在许多属性让我们能够读取元素的宽度、高度或
 在大多数实际情况下，我们可以使用 `offsetParent` 来获得最近的 CSS 定位祖先。`offsetLeft/offsetTop` 提供相对于元素左上角的 x/y 坐标。
 
 在下面的例子中，内部 `<div>` 有 `<main>` 作为 `offsetParent`，并且 `offsetLeft/offsetTop` 让它从左上角位移（`180`）：
+=======
+1. CSS-positioned (`position` is `absolute`, `relative`, `fixed` or `sticky`),
+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 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`):
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html run height=10
 <main style="position: relative" id="main">
@@ -201,8 +211,13 @@ element.style.height = `${element.scrollHeight}px`;
 
 换种说法，`scrollTop` 就是 “滚动了多少” 的意思。
 
+<<<<<<< HEAD
 ````smart header="`scrollLeft/scrollTop` 可修改 "
 大多数几何属性是只读的，但是 `scrollLeft/scrollTop` 可以改变，浏览器将会直接滚动元素。
+=======
+````smart header="`scrollLeft/scrollTop` can be modified"
+Most of the geometry properties here are read-only, but `scrollLeft/scrollTop` can be changed, and the browser will scroll the element.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```online
 如果单击下面的元素，代码 `elem.scrollTop += 10` 将会执行，这使得元素向下滚动 `10px`。
@@ -264,6 +279,7 @@ alert( getComputedStyle(elem).width ); // show CSS width for elem
 
 元素具有以下几何属性：
 
+<<<<<<< HEAD
 - `offsetParent` — 是最近的有定位属性的祖先元素，或者是 `td`、`th`、`table`、`body`。
 - `offsetLeft/offsetTop` — 是相对于 `offsetParent` 的左上角边缘坐标。
 - `offsetWidth/offsetHeight` — 元素的“外部”宽/高 ，边框尺寸计算在内。
@@ -271,5 +287,14 @@ alert( getComputedStyle(elem).width ); // show CSS width for elem
 - `clientWidth/clientHeight` — 内容的宽度/高度，包括内间距，但没有滚动条。
 - `scrollWidth/scrollHeight` — 内容的宽度/高度，包括可滚动的可视区域外的尺寸，也包括内间距，但不包括滚动条。
 - `scrollLeft/scrollTop` — 从左上角开始的元素的滚动部分的宽度/高度。
+=======
+- `offsetParent` -- is the nearest positioned ancestor or `td`, `th`, `table`, `body`.
+- `offsetLeft/offsetTop` -- coordinates relative to the upper-left edge of `offsetParent`.
+- `offsetWidth/offsetHeight` -- "outer" width/height of an element including borders.
+- `clientLeft/clientTop` -- the distance from the upper-left outer corner to its upper-left inner corner. For left-to-right OS they are always the widths of left/top borders. For right-to-left OS the vertical scrollbar is on the left so `clientLeft` includes its width too.
+- `clientWidth/clientHeight` -- the width/height of the content including paddings, but without the scrollbar.
+- `scrollWidth/scrollHeight` -- the width/height of the content including the scrolled out parts. Also includes paddings, but not the scrollbar.
+- `scrollLeft/scrollTop` -- width/height of the scrolled out part of the element, starting from its upper-left corner.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 除了 `scrollLeft/scrollTop` 之外，所有属性都是只读的。如果更改，浏览器会使元素滚动。
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 6deec90821..6060b9890b 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 e084c257b1..3c53be1dd6 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 ffb10aa1bd..efcc9440b5 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 48510e6e09..9b7edcf572 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 33faf9be7d..787557205a 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 a8e170eabf..8034c7aff9 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 ed44652d89..d50d1186ff 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 f31f483e46..76017b9ee6 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 a183c6b384..173bf1529b 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 5a73f87a97..2d145d77fc 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 564c210a99..5579b4abdb 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 e4fd7bb878..c4df7706b2 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 01d2d00087..059ef13efa 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 125a91e153..0f86b4f858 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 a13075f03a..82551b8e1c 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 7bfb24c221..805687cd6b 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 4bc795aa0e..83f410837c 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 bf0cf711a9..1ef15502e7 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 581c214437..54e6b96344 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 1e2a20f546..d57c5c198f 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 c3902788a8..73e6622721 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,10 @@
 # Window 的尺寸和滚动
 
+<<<<<<< HEAD
 怎么找到浏览器窗口的宽度呢？如何获得包括滚动窗口外部分的文档总高度呢？如何通过 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?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在 DOM 里，文档的根元素是 `document.documentElement`。与之相对应的标签是 `<html>`，同时它具备了[前一章](info:size-and-scroll)的几何属性。只有在某些情景下，我们可以使用到它，但还有其他方法和特性需要我们去特别考虑的。
 
@@ -45,7 +49,11 @@ alert( document.documentElement.clientWidth ); // 窗口减去滚动条的宽度
 
 这几个属性对常规元素能起作用，但面对整个页面它们会失去它们应有的作用了。在 Chrome/Safari/Opera 浏览器，如果这里没有滚动条，`documentElement.scrollHeight` 甚至比 `documentElement.clientHeight` 小！这对常规元素来讲是不可能出现的情况。
 
+<<<<<<< HEAD
 要获得可靠的窗口大小，我们应该采用这些属性的最大值：
+=======
+To have a reliable result on the full document height, we should take the maximum of these properties:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let scrollHeight = Math.max(
@@ -97,7 +105,11 @@ alert('Current scroll from the left: ' + window.pageXOffset);
 
     <button onclick="window.scrollBy(0,10)">window.scrollBy(0,10)</button>
     ```
+<<<<<<< HEAD
 - 方法 `scrollTo(pageX,pageY)` 滚动页面至相对于文档的左上角的 (pageX, pageY) 位置。就好像设置 `scrollLeft/scrollTop`。
+=======
+- The method `scrollTo(pageX,pageY)` scrolls the page relative to the document's top-left corner. It's like setting `scrollLeft/scrollTop`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     回到顶部, 我们可以用 `scrollTo(0,0)`。
 
@@ -130,7 +142,11 @@ alert('Current scroll from the left: ' + window.pageXOffset);
 
 有时候我们需要让文档禁止滚动。例如，当我们需要用一个被立即关注的消息框覆盖这个文档时，我们希望访问者与这个消息进行交互，而不是与文档进行交互。
 
+<<<<<<< HEAD
 想让这个文档禁止滚动，设置`document.body.style.overflow = "hidden"`就够了。该页面将“冻结”其当前滚动。
+=======
+To make the document unscrollable, it's enough to set `document.body.style.overflow = "hidden"`. The page will freeze on its current scroll.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```online
 试一试：
@@ -146,7 +162,11 @@ alert('Current scroll from the left: ' + window.pageXOffset);
 
 这个方法的缺点是会使滚动条消失。如果它占用了一些空间，它原本占用的空间就会空出来，使元素本身的内容“跳”出来填满空出来的空间里。
 
+<<<<<<< HEAD
 这看起来就有点怪怪的。但我们可以解决这个问题：通过对比冻结前后的`clientWidth`如果在 `clientWidth` 增加（滚动条消失）时，将 `padding` 添加到 `document.body` 取代滚动条来保持内容宽度不变。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 总结
 
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 76a45a7a7f..a3cf95f118 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 249db0edbe..868dc8a266 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/1-find-point-coordinates/task.md b/2-ui/1-document/11-coordinates/1-find-point-coordinates/task.md
index 66209a3a0d..a6b49a4b53 100644
--- a/2-ui/1-document/11-coordinates/1-find-point-coordinates/task.md
+++ b/2-ui/1-document/11-coordinates/1-find-point-coordinates/task.md
@@ -14,10 +14,17 @@ importance: 5
 
 你的代码应该使用 DOM 来获取到以下窗口坐标：
 
+<<<<<<< HEAD
 1. 左上的外角（这很简单）。
 2. 右下的外角（这也挺简单）。
 3. 左上的内角（这有点难）。
 4. 右下的内角（有几种方式，选择其中一种）。
+=======
+1. Upper-left, outer corner (that's simple).
+2. Bottom-right, outer corner (simple too).
+3. Upper-left, inner corner (a bit harder).
+4. Bottom-right, inner corner (there are several ways, choose one).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 你计算得到的坐标应该和鼠标单击返回的坐标相同。
 
diff --git a/2-ui/1-document/11-coordinates/2-position-at/solution.md b/2-ui/1-document/11-coordinates/2-position-at/solution.md
index 0ebe4ccc35..beb143e345 100644
--- a/2-ui/1-document/11-coordinates/2-position-at/solution.md
+++ b/2-ui/1-document/11-coordinates/2-position-at/solution.md
@@ -1,4 +1,8 @@
+<<<<<<< HEAD
 在这个任务中我们只需要精确计算坐标。具体细节可以在代码中查看。
+=======
+In this task we only need to accurately calculate the coordinates. See the code for details.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 请注意：元素必须位于在文档中才能读取 `offsetHeight` 和其它属性。
 一个元素如果有隐藏的（`display:none`）样式或者坐标范围超出文档是得不到大小的。
\ No newline at end of file
diff --git a/2-ui/1-document/11-coordinates/2-position-at/task.md b/2-ui/1-document/11-coordinates/2-position-at/task.md
index bbecc21d1f..9b396f2819 100644
--- a/2-ui/1-document/11-coordinates/2-position-at/task.md
+++ b/2-ui/1-document/11-coordinates/2-position-at/task.md
@@ -6,7 +6,11 @@ importance: 5
 
 基于 `anchor` 元素的上边（`"top"`），右边（`"right"`）或者底部（`"bottom"`）的 `position`，创建一个 `positionAt(anchor, position, elem)` 函数来定位 `elem` 元素。
 
+<<<<<<< HEAD
 使用这个函数构建一个 `showNote(anchor, position, html)` 函数，它使用类 `"note"` 和文本 `html` 标签在 anchor 位置旁边显示一个元素。
+=======
+Call it inside the function `showNote(anchor, position, html)` that shows an element with the class `"note"` and the text `html` at the given position near the anchor.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 注释像下面这样显示：
 
diff --git a/2-ui/1-document/11-coordinates/article.md b/2-ui/1-document/11-coordinates/article.md
index 5de325796d..578058c7be 100644
--- a/2-ui/1-document/11-coordinates/article.md
+++ b/2-ui/1-document/11-coordinates/article.md
@@ -11,7 +11,11 @@
 
 ## 窗口坐标：getBoundingClientRect
 
+<<<<<<< HEAD
 窗口的坐标是从窗口的左上角开始计算的。
+=======
+Window coordinates start at the upper-left corner of the window.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `elem.getBoundingClientRect()` 方法返回一个 `elem` 的窗口坐标对象，这个对象有以下这些属性：
 
@@ -25,7 +29,11 @@
 ![](coords.png)
 
 
+<<<<<<< HEAD
 窗口坐标并不会考虑到文档滚动，它们就是基于窗口的左上角计算出来的。
+=======
+Window coordinates do not take the scrolled out part of the document into account, they are calculated from the window's upper-left corner.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 换句话说，当我们滚动这个页面，这个元素就会上升或者下降，**它的窗口坐标改变了**。这很重要。
 
@@ -46,6 +54,7 @@ function showRect(elem) {
 
 额外说明：
 
+<<<<<<< HEAD
 - 坐标可以是十进制的分数。这很正常，浏览器内部也是使用十进制分数来计算坐标。当设置元素的 `style.position.left/top` 时我们不需要舍入它们，浏览器可以支持十进制分数。
 - 坐标也可以是负数的。例如当我们滚动页面向下在 `elem` 的顶部超过窗口的时候，这时候我们调用 `elem.getBoundingClientRect().top` 返回的就是负数。
 - 一些浏览器（像 Chrome）还会在 `getBoundingClientRect` 的返回中增加 `width` 和 `height` 属性。我们可以通过减法计算 `height=bottom-top`，`width=right-left` 来得到这两个属性。
@@ -57,6 +66,18 @@ function showRect(elem) {
 但是在 CSS 中 `right` 属性表示的是到右边界的距离，而且 `bottom` 是到底部边界的距离。
 
 如果我们只看下面的图片，我们可以看到在 JavaScript 中并非如此。所有窗口坐标都是从左上角开始计算的，包括这些坐标。
+=======
+- 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` 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.
+
+But in CSS, the `right` property means the distance from the right edge, and the `bottom` property means the distance from the bottom edge.
+
+If we just look at the picture above, we can see that in JavaScript it is not so. All window coordinates are counted from the upper-left corner, including these ones.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ## elementFromPoint(x, y) [#elementFromPoint]
@@ -155,7 +176,11 @@ setTimeout(() => message.remove(), 5000);
 
 ## 文档坐标
 
+<<<<<<< HEAD
 文档相对坐标是从文档的左上角开始计算，而不是窗口。
+=======
+Document-relative coordinates start from the upper-left corner of the document, not the window.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在 CSS 中，窗口坐标对应的是 `position:fixed`，而文档坐标则类似顶部的 position:absolute`。
 
@@ -180,7 +205,11 @@ setTimeout(() => message.remove(), 5000);
 
 ## 获取文档坐标 [#getCoords]
 
+<<<<<<< HEAD
 现在 Javascript 中并没有获取一个元素文档坐标的标准方法。但是这个方法写起来很容易。
+=======
+There's no standard method to get the document coordinates of an element. But it's easy to write it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 两个坐标系可以通过由公式相连接：
 - `pageY` = `clientY` + 文档垂直部分滚动的高度。
diff --git a/2-ui/1-document/11-coordinates/coords.png b/2-ui/1-document/11-coordinates/coords.png
index 58fd533fba..79d1fdbb65 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 c3469f4cde..d3e340f50b 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 39ddc31c3c..29c59aad1c 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 52e555c490..3c188ee455 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 706b42c110..3dc17f0256 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 83f31950c0..45f6b9e7fd 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/1-document/11-coordinates/head.html b/2-ui/1-document/11-coordinates/head.html
index bba7bec068..4ec5572082 100644
--- a/2-ui/1-document/11-coordinates/head.html
+++ b/2-ui/1-document/11-coordinates/head.html
@@ -1,9 +1,17 @@
 <script>
 document.addEventListener('DOMContentLoaded', function() {
 
+<<<<<<< HEAD
   let elem = document.getElementById('coords-show-mark');
 
   elem && elem.getElementById('coords-show-mark').onclick = function() {
+=======
+let elem = document.getElementById('coords-show-mark');
+
+// no elem in ebook mode
+if (elem) {
+  elem.onclick = function() {
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
     function createMessageUnder(elem, text) {
       let coords = elem.getBoundingClientRect();
@@ -22,6 +30,7 @@
     document.body.append(message);
     setTimeout(() => message.remove(), 5000);
   }
+}
 
 });
 
diff --git a/2-ui/2-events/01-introduction-browser-events/02-hide-self-onclick/solution.md b/2-ui/2-events/01-introduction-browser-events/02-hide-self-onclick/solution.md
index c9fa4993f9..8312b743ec 100644
--- a/2-ui/2-events/01-introduction-browser-events/02-hide-self-onclick/solution.md
+++ b/2-ui/2-events/01-introduction-browser-events/02-hide-self-onclick/solution.md
@@ -1,4 +1,8 @@
+<<<<<<< HEAD
 可以在处理器中使用 `this` 来引用自身：
+=======
+Can use `this` in the handler to reference "the element itself" here:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html run height=50
 <input type="button" onclick="this.hidden=true" value="Click to hide">
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 ca2f49edbb..4a0549582e 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 b4c4d3ef24..ecf4e5d2ff 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 5a86933435..f1a2b3e555 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,17 +33,21 @@
 要获取单击字段的相对 `left` 坐标，我们可以减去字段的左边缘和边框宽度：
 
 ```js
-let left = event.clientX - fieldInnerCoords.left - field.clientLeft;
+let left = event.clientX - fieldCoords.left - field.clientLeft;
 ```
 
+<<<<<<< HEAD
 通常情况下，`ball.style.position.left` 是指“元素的左边缘”（球）。因此，如果我们指定 `left`，那么球的边缘就会在鼠标光标下面。
+=======
+Normally, `ball.style.position.left` means the "left edge of the element" (the ball). So if we assign that `left`, then the ball edge, not center, would be under the mouse cursor.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 我们需要将球向左移动宽度的一半，向上移动高度的一半，使其居中。
 
 因此，最后 `left` 是：
 
 ```js
-let left = event.clientX - fieldInnerCoords.left - field.clientLeft - ball.offsetWidth/2;
+let left = event.clientX - fieldCoords.left - field.clientLeft - ball.offsetWidth/2;
 ```
 
 使用相同的逻辑计算垂直坐标。
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 8a7bc1ad57..e1d7de1956 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,15 @@
 # HTML/CSS
 首先，我们创建 HTML/CSS。
 
+<<<<<<< HEAD
 菜单是页面上的一个独立的图形组件，所以最好把它放在一个 DOM 元素中。
 
 菜单项列表可以分层为列表 `ul/li`。
+=======
+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 laid out as a list `ul/li`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 下面是示例的结构：
 
@@ -29,7 +35,11 @@
 
 因此如果我们在它上面设置 `onclick`，就会在文本的右边捕获点击事件。
 
+<<<<<<< HEAD
 ...但 `<span>` 有一个隐式 `display: inline`，因此它会占据足够的位置来适应所有的文本：
+=======
+As `<span>` has an implicit `display: inline`, it occupies exactly enough place to fit all the text:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html autorun height=50
 <span style="border: solid red 1px" onclick="alert(1)">Sweeties (click me)!</span>
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 6e481b0aa7..79d53a4154 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,11 @@ importance: 5
 
 ---
 
+<<<<<<< HEAD
 # 创建滑动菜单
+=======
+# Create a sliding menu
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 创建一个在单击时打开/折叠的菜单：
 
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 b58ac0a66d..93defb0bbb 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 fe6a0badd7..7aa0d0f84b 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 351ead9c4e..a61bf5e579 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 05dbc1adf5..4742579db6 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 88eb7e8acb..3dab1fe4e0 100644
--- a/2-ui/2-events/01-introduction-browser-events/article.md
+++ b/2-ui/2-events/01-introduction-browser-events/article.md
@@ -18,8 +18,13 @@
 **键盘事件**：
 - `keydown` and `keyup` —— 当访问者按下然后松开按钮时。
 
+<<<<<<< HEAD
 **Document 事件**：
 - `DOMContentLoaded` —— 当加载和处理 HTML 时，DOM 将会被完整地构建。
+=======
+**Document events:**
+- `DOMContentLoaded` -- when the HTML is loaded and processed, DOM is fully built.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 **CSS 事件**：
 - `transitionend` —— 当 CSS 动画完成时。
@@ -30,7 +35,11 @@
 
 为了响应事件，我们可以通过分发**处理器** —— 在事件发生时运行的函数。
 
+<<<<<<< HEAD
 处理器是在用户操作时运行 JavaScript 代码的一种方法。
+=======
+Handlers are a way to run JavaScript code in case of user actions.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 有许多分发处理器的方法。我们来看看，从最简单的开始。
 
@@ -160,9 +169,15 @@ button.onclick = sayThanks;
 button.onclick = sayThanks();
 ```
 
+<<<<<<< HEAD
 如果我们添加括号，那么就是 `sayThanks()` —— 将是函数执行的**结果**，所以最后一行代码中的 `onclick` 变成了 `undefined`（函数返回的内容将什么也没有）。这是不可取的。
 
 ...但在标记中，我们确实需要括号：
+=======
+If we add parentheses, `sayThanks()` --  is a function call. So the last line actually takes the *result* of the function execution, that is `undefined` (as the function returns nothing), and assigns it to `onclick`. That doesn't work.
+
+...But in the markup we do need the parentheses:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html
 <input type="button" id="button" onclick="sayThanks()">
@@ -216,7 +231,7 @@ Web 标准的开发者很久之前就明白了这一点，并提出了一种使
 添加处理器的语法：
 
 ```js
-element.addEventListener(event, handler[, phase]);
+element.addEventListener(event, handler[, options]);
 ```
 
 `event`
@@ -225,15 +240,24 @@ element.addEventListener(event, handler[, phase]);
 `handler`
 : 处理器函数。
 
+<<<<<<< HEAD
 `phase`
 : 一个可选的参数，即处理器的工作“阶段”。之后会讨论。我们通常不会使用它。
 
 使用 `removeEventListener` 移除处理器：
+=======
+`options`
+: An additional optional object with properties:
+    - `once`: if `true`, then the listener is automatically removed after it triggers.
+    - `capture`: the phase 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>.
+
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
+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"
@@ -288,8 +312,13 @@ input.removeEventListener("click", handler);
 
 正如我们在以上所看到的那样，我们可以使用 DOM 属性**和** `addEventListener` 来设置处理器。但通常我们只使用其中一种方法。
 
+<<<<<<< HEAD
 ````warn header="有些事件处理器只能通过 `addEventListener` 设置"
 有些事件不能通过 DOM 属性分配。必须使用 `addEventListener`。
+=======
+````warn header="For some events, handlers only work with `addEventListener`"
+There exist events that can't be assigned via a DOM-property. Must use `addEventListener`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 事件 `transitionend`（CSS 动画完成）就是如此。
 
@@ -349,12 +378,20 @@ input.removeEventListener("click", handler);
 : 事件类型，这里是 `"click"`。
 
 `event.currentTarget`
+<<<<<<< HEAD
 : 处理事件的元素。这与 `this` 相同，除非你将 `this` 绑定到其他东西上，之后 `event.currentTarget` 就会有效了。
+=======
+: Element that handled the event. That's exactly the same as `this`, unless the handler is an arrow function, or its `this` is bound to something else, then `event.currentTarget` becomes useful.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `event.clientX / event.clientY`
 : 鼠标事件中光标相对于窗口的坐标。
 
+<<<<<<< HEAD
 还有更多属性。他们取决于事件类型，因此我们稍后将在详细讨论不同事件时来研究它们。
+=======
+There are more properties. They depend on the event type, so we'll study them later when we come to different events in details.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ````smart header="事件对象也可以从 HTML 访问"
 如果我们在 HTML 中分发一个处理器，我们也可以使用 `event` 对象，如下所示：
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 d0235ea534..ad97f401cc 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -10,7 +10,11 @@
 </div>
 ```
 
+<<<<<<< HEAD
 这很奇怪不是么？为什么实际上是单击 `<em>`，而 `<div>` 上的处理器会运行？
+=======
+Isn't it a bit strange? Why does the handler on `<div>` run if the actual click was on `<em>`?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 冒泡
 
@@ -18,7 +22,11 @@
 
 **当事件发生在元素上，它首先会运行元素本身的处理器，然后运行父元素上的，再然后是其他祖先上的**。
 
+<<<<<<< HEAD
 比如我们有 3 层嵌套 `FORM > DIV > P`，它们都各自拥有一个处理器：
+=======
+Let's say we have 3 nested elements `FORM > DIV > P` with a handler on each of them:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html run autorun
 <style>
@@ -108,9 +116,15 @@
 
 例如：
 
+<<<<<<< HEAD
 1. 我们创建一个嵌套目录，每个子目录各自处理对自己的单击事件，并调用 `stopPropagation`，这样外层目录就不会被触发。
 2. 之后我们决定去捕获在整个窗口上的点击，来追踪用户的行为（用户点击了哪里）。有些分析系统会这样做。通常代码会使用 `document.addEventListener('click'…)` 来捕获所有的点击。
 3. 我们的分析不适用于点击被 `stopPropagation` 所阻止的区域。我们有一个 "dead zone"。
+=======
+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".
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 通常没有必要去阻止冒泡的产生。看似需要的任务，可以通过其他方法解决。其中之一就是使用自定义事件，我们稍后会进行讨论。此外，我们还可以将数据写入一个处理器中的 `event` 对象，并在另一个处理器中读取它，这样我们就可以向父处理器传递有关下层处理器的信息。
 ```
@@ -136,18 +150,34 @@
 
 处理器 `on<event>` 属性或使用 HTML 属性或者使用 `addEventListener(event, handler)` 添加的处理器，不知道捕获，它们只知道第 2 和第 3 阶段。
 
+<<<<<<< HEAD
 要在捕获阶段捕获事件，我们需要将 `addEventListener` 的第三个参数设置为 `true`。
 
 最后一个参数是可选的，有两个可能的值：
+=======
+To catch an event on the capturing phase, we need to set the handler `capture` option to `true`:
+
+```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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 - 如果为 `false`（默认值），则在冒泡阶段设置处理器。
 - 如果为 `true`，则在捕获阶段设置处理器。
 
 注意，虽然形式上有 3 个阶段，但第 2 阶段（“目标阶段”：事件到达元素）没有单独被处理：捕获阶段和冒泡阶段的处理器在该阶段都会被触发。
 
+<<<<<<< HEAD
 如果将捕获阶段和冒泡阶段处理器放在目标上，捕获阶段处理器将在捕获阶段触发，而冒泡处理器将首先在冒泡阶段被触发。
 
 我们看一下效果：
+=======
+Let's see both capturing and bubbling in action:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html run autorun height=140 edit
 <style>
@@ -182,13 +212,27 @@
 
 有一个 `event.eventPhase` 属性，它告诉我们事件被捕获阶段的数量。但它很少使用，因为我们通常在处理器中了解到它。
 
+<<<<<<< HEAD
 ## 总结
+=======
+```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
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 事件处理过程：
 
+<<<<<<< HEAD
 - 当事件发生时 —— 嵌套最深的那个元素被标记为“目标事件”(`event.target`)。
 - 然后事件先从文档根节点向下移动到 `event.target`，过程中调用分配给 `addEventListener(...., true)` 的处理器。
 - 再然后事件从 `event.target` 向上移动到根，调用使用 `on<event>` 和 `addEventListener` 分配的处理器，不使用第三个参数或第三个参数设置为 `false`。
+=======
+- 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 (`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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 每个处理器都可以访问 `event` 对象属性：
 
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 a4f4fae511..9de1f20483 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 e3a070cb80..81bb24c703 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 95c5c08e0a..56fa230a60 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 d52c4f70c9..17ab1bf8ee 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/4-behavior-tooltip/solution.view/index.html b/2-ui/2-events/03-event-delegation/4-behavior-tooltip/solution.view/index.html
index 31d0d46b12..1ef37cdc90 100644
--- a/2-ui/2-events/03-event-delegation/4-behavior-tooltip/solution.view/index.html
+++ b/2-ui/2-events/03-event-delegation/4-behavior-tooltip/solution.view/index.html
@@ -15,7 +15,7 @@
       border: 1px solid #b3c9ce;
       border-radius: 4px;
       text-align: center;
-      font: italic 14px/1.3 arial, sans-serif;
+      font: italic 14px/1.3 sans-serif;
       color: #333;
       background: #fff;
       box-shadow: 3px 3px 3px rgba(0, 0, 0, .3);
diff --git a/2-ui/2-events/03-event-delegation/4-behavior-tooltip/source.view/index.html b/2-ui/2-events/03-event-delegation/4-behavior-tooltip/source.view/index.html
index 57a19d01a8..add3b21442 100644
--- a/2-ui/2-events/03-event-delegation/4-behavior-tooltip/source.view/index.html
+++ b/2-ui/2-events/03-event-delegation/4-behavior-tooltip/source.view/index.html
@@ -16,7 +16,7 @@
       border: 1px solid #b3c9ce;
       border-radius: 4px;
       text-align: center;
-      font: italic 14px/1.3 arial, sans-serif;
+      font: italic 14px/1.3 sans-serif;
       color: #333;
       background: #fff;
       box-shadow: 3px 3px 3px rgba(0, 0, 0, .3);
diff --git a/2-ui/2-events/03-event-delegation/article.md b/2-ui/2-events/03-event-delegation/article.md
index efd818cc8f..1760fa0d46 100644
--- a/2-ui/2-events/03-event-delegation/article.md
+++ b/2-ui/2-events/03-event-delegation/article.md
@@ -1,7 +1,11 @@
 
 # 事件委托
 
+<<<<<<< HEAD
 捕获和冒泡允许实现一种称为**事件委托**的强大的事件处理模式。
+=======
+Capturing and bubbling allow us to implement one of most powerful event handling patterns called *event delegation*.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 我们的想法是，如果我们有许多元素是以类似的方式处理的，那么我们就不需要给每个元素分配一个处理器 —— 而是在它们共同的祖先上面添加一个处理器。
 
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 f0433aeb18..55adbd0c13 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 8cc5ca913f..86b6d68076 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/2-catch-link-navigation/task.md b/2-ui/2-events/04-default-browser-action/2-catch-link-navigation/task.md
index 28f1fb60dc..b7d9ae23f0 100644
--- a/2-ui/2-events/04-default-browser-action/2-catch-link-navigation/task.md
+++ b/2-ui/2-events/04-default-browser-action/2-catch-link-navigation/task.md
@@ -4,7 +4,11 @@ importance: 5
 
 # 在元素中捕获链接
 
+<<<<<<< HEAD
 在所有包含 `id="contents"` 属性元素的链接（在触发单击事件时）询问用户是否真的想离开当前页面。 
+=======
+Make all links inside the element with `id="contents"` ask the user if they really want to leave. And if they don't then don't follow.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 就像这样：
 
diff --git a/2-ui/2-events/04-default-browser-action/3-image-gallery/solution.view/gallery.css b/2-ui/2-events/04-default-browser-action/3-image-gallery/solution.view/gallery.css
index 66690e53ea..4522006aee 100644
--- a/2-ui/2-events/04-default-browser-action/3-image-gallery/solution.view/gallery.css
+++ b/2-ui/2-events/04-default-browser-action/3-image-gallery/solution.view/gallery.css
@@ -1,16 +1,16 @@
 body {
   margin: 0;
   padding: 0;
-  font: 75%/120% Arial, Helvetica, sans-serif;
+  font: 75%/120% sans-serif;
 }
 
 h2 {
-  font: bold 190%/100% Arial, Helvetica, sans-serif;
+  font: bold 190%/100% sans-serif;
   margin: 0 0 .2em;
 }
 
 h2 em {
-  font: normal 80%/100% Arial, Helvetica, sans-serif;
+  font: normal 80%/100% sans-serif;
   color: #999999;
 }
 
diff --git a/2-ui/2-events/04-default-browser-action/3-image-gallery/source.view/gallery.css b/2-ui/2-events/04-default-browser-action/3-image-gallery/source.view/gallery.css
index 0c5061c23d..b6e523014d 100644
--- a/2-ui/2-events/04-default-browser-action/3-image-gallery/source.view/gallery.css
+++ b/2-ui/2-events/04-default-browser-action/3-image-gallery/source.view/gallery.css
@@ -1,16 +1,16 @@
 body {
   margin: 0;
   padding: 0;
-  font: 75%/120% Arial, Helvetica, sans-serif;
+  font: 75%/120% sans-serif;
 }
 
 h2 {
-  font: bold 190%/100% Arial, Helvetica, sans-serif;
+  font: bold 190%/100% sans-serif;
   margin: 0 0 .2em;
 }
 
 h2 em {
-  font: normal 80%/100% Arial, Helvetica, sans-serif;
+  font: normal 80%/100% sans-serif;
   color: #999999;
 }
 
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 b57696907f..5a2225e468 100644
--- a/2-ui/2-events/04-default-browser-action/article.md
+++ b/2-ui/2-events/04-default-browser-action/article.md
@@ -17,7 +17,11 @@
 - 主流的方法是使用 `event` 对象。有一个 `event.preventDefault()` 方法。
 - 如果使用 `on<event>`（而不是 `addEventListener`）分发处理器，那么我们只需要从它内部返回 `false` 即可。
 
+<<<<<<< HEAD
 在下面的示例中，单击链接不会导致 URL 改变：
+=======
+In the example below a click to links doesn't lead to URL change:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```html autorun height=60 no-beautify
 <a href="/" onclick="return false">Click here</a>
@@ -93,6 +97,20 @@ menu.onclick = function(event) {
 
 这是因为浏览器动作在 `mousedown` 上被取消。如果我们用另一种方式进行输入，焦点仍然有用。例如，`key:Tab` 键用于从第一个输入切换到第二个输入。但不要再用鼠标单击了。
 
+## 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,12 +233,22 @@ menu.onclick = function(event) {
 
 想要阻止默认行为 —— 可以使用 `event.preventDefault()` 或者 `return false`。第二个方法只适用于分发了 `on<event>` 的处理器。
 
+<<<<<<< HEAD
 如果默认动作被阻止，`event.defaultPrevented` 的值就会变成 `true`，否则会变成 `false`。
+=======
+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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```warn header="Stay semantic, don't abuse"
 从技术上来说，通过阻止默认动作和添加 JavaScript，我们可以定制任何元素的行为。例如，我们可以使链接 `<a>` 像按钮一样工作，而按钮 `<button>` 也可以作为链接运行（重定向到另一个 URL 等）。
 
+<<<<<<< HEAD
 但我们通常应该保留 HTML 元素的语义。例如 `<a>` 应该表现为导航，而不是按钮。
+=======
+But we should generally keep the semantic meaning of HTML elements. For instance, `<a>` should perform navigation, not a button.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 除了“是一件好事”，这使你的 HTML 在可访问性方便表现得更好。
 
diff --git a/2-ui/2-events/04-default-browser-action/menu.view/menu.css b/2-ui/2-events/04-default-browser-action/menu.view/menu.css
index 4c172e0515..32494ae9be 100644
--- a/2-ui/2-events/04-default-browser-action/menu.view/menu.css
+++ b/2-ui/2-events/04-default-browser-action/menu.view/menu.css
@@ -9,7 +9,7 @@
   outline: none;
   text-align: center;
   text-decoration: none;
-  font: 14px/100% Arial, Helvetica, sans-serif;
+  font: 14px/100% sans-serif;
   padding: .5em 2em .55em;
   text-shadow: 0 1px 1px rgba(0, 0, 0, .3);
   border-radius: .5em;
diff --git a/2-ui/2-events/05-dispatch-events/article.md b/2-ui/2-events/05-dispatch-events/article.md
index eca74ad5d4..274e5f2f21 100644
--- a/2-ui/2-events/05-dispatch-events/article.md
+++ b/2-ui/2-events/05-dispatch-events/article.md
@@ -149,7 +149,7 @@ alert(event.clientX); // undefined, the unknown property is ignored!
 *!*
     detail: { name: "John" }
 */!*
-  });
+  }));
 </script>
 ```
 
@@ -268,9 +268,15 @@ alert(event.clientX); // undefined, the unknown property is ignored!
 
 要生成一个事件，我们首先需要创建一个事件对象。
 
+<<<<<<< HEAD
 泛型 `Event(name, options)` 构造器接受任意事件名，`options` 对象具有两个属性：
   - `bubbles: true` ，如果事件应该冒泡的话。
   - `cancelable: true` 则 `event.preventDefault()` 应该有效。
+=======
+The generic `Event(name, options)` constructor accepts an arbitrary event name and the `options` object with two properties:
+  - `bubbles: true` if the event should bubble.
+  - `cancelable: true` if the `event.preventDefault()` should work.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 其他像 `MouseEvent`、`KeyboardEvent` 这样的原生事件构造器，接受特定于该事件类型的属性。例如，鼠标事件的 `clientX`。
 
diff --git a/2-ui/2-events/index.md b/2-ui/2-events/index.md
index 4fd273eaf8..953d9c7950 100644
--- a/2-ui/2-events/index.md
+++ b/2-ui/2-events/index.md
@@ -1,3 +1,7 @@
+<<<<<<< HEAD
 # 事件简介
+=======
+# Introduction to Events
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 浏览器事件、事件属性和处理模式简介。
diff --git a/2-ui/3-event-details/1-mouse-events-basics/article.md b/2-ui/3-event-details/1-mouse-events-basics/article.md
index 6f9ebe1f32..f147181a93 100644
--- a/2-ui/3-event-details/1-mouse-events-basics/article.md
+++ b/2-ui/3-event-details/1-mouse-events-basics/article.md
@@ -175,7 +175,11 @@ Before...
 
 ...但有一个潜在的问题！文本变得无法被选中。即使用户从“之前”开始选择，“之后”结束，选择也会跳过“不可选择”部分。我们真的想让文本不可选么？
 
+<<<<<<< HEAD
 大部分时间，我们不会那么做。用户可能有合理的理由来选择文本，以便进行复制或其他需要。如果我们不让他那么做那么可能不太方便。所以这个解决方案没那么好。
+=======
+Most of time, we don't. A user may have valid reasons to select the text, for copying or other needs. That may be inconvenient if we don't allow them to do it. So this solution is not that good.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 我们只是想阻止双击进行选择，仅此而已。
 
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/1-behavior-nested-tooltip/solution.view/index.html b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/1-behavior-nested-tooltip/solution.view/index.html
index 8fbae4c790..e998165fd2 100644
--- a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/1-behavior-nested-tooltip/solution.view/index.html
+++ b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/1-behavior-nested-tooltip/solution.view/index.html
@@ -18,7 +18,7 @@
       border: 1px solid #b3c9ce;
       border-radius: 4px;
       text-align: center;
-      font: italic 14px/1.3 arial, sans-serif;
+      font: italic 14px/1.3 sans-serif;
       color: #333;
       background: #fff;
       box-shadow: 3px 3px 3px rgba(0, 0, 0, .3);
@@ -78,12 +78,13 @@
     }
 
     document.onmouseout = function() {
-      // it is possible that mouseout triggered, but we're still inside the element (cause of bubbling)
+      // it is possible that mouseout triggered, but we're still inside the element
+      // (its target was inside, and it bubbled)
       // but in this case we'll have an immediate mouseover,
       // so the tooltip will be destroyed and shown again
       //
-      // that's an overhead, but here it's not visible
-      // can be fixed with additional checks
+      // luckily, the "blinking" won't be visible,
+      // as both events happen almost at the same time
       if (tooltip) {
         tooltip.remove();
         tooltip = false;
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/1-behavior-nested-tooltip/source.view/index.html b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/1-behavior-nested-tooltip/source.view/index.html
index 8abb923d5e..2dc4394e74 100644
--- a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/1-behavior-nested-tooltip/source.view/index.html
+++ b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/1-behavior-nested-tooltip/source.view/index.html
@@ -18,7 +18,7 @@
       border: 1px solid #b3c9ce;
       border-radius: 4px;
       text-align: center;
-      font: italic 14px/1.3 arial, sans-serif;
+      font: italic 14px/1.3 sans-serif;
       color: #333;
       background: #fff;
       box-shadow: 3px 3px 3px rgba(0, 0, 0, .3);
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/solution.view/hoverIntent.js b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/solution.view/hoverIntent.js
index a78c7c5554..4e6e2a3e95 100644
--- a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/solution.view/hoverIntent.js
+++ b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/solution.view/hoverIntent.js
@@ -101,6 +101,6 @@ class HoverIntent {
     elem.removeEventListener('mousemove', this.onMouseMove);
     elem.removeEventListener('mouseover', this.onMouseOver);
     elem.removeEventListener('mouseout', this.onMouseOut);
-  };
+  }
 
 }
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/solution.view/style.css b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/solution.view/style.css
index f0736f3e35..fa2f09eba8 100644
--- a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/solution.view/style.css
+++ b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/solution.view/style.css
@@ -30,7 +30,7 @@ body {
   border: 1px solid #b3c9ce;
   border-radius: 4px;
   text-align: center;
-  font: italic 14px/1.3 arial, sans-serif;
+  font: italic 14px/1.3 sans-serif;
   color: #333;
   background: #fff;
   z-index: 100000;
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/source.view/hoverIntent.js b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/source.view/hoverIntent.js
index 29198d8eac..caca940b1d 100644
--- a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/source.view/hoverIntent.js
+++ b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/source.view/hoverIntent.js
@@ -45,6 +45,6 @@ class HoverIntent {
 
   destroy() {
     /* your code to "disable" the functionality, remove all handlers */
-  };
+  }
 
 }
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/source.view/index.html b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/source.view/index.html
index 702b79f968..856daf3a8f 100644
--- a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/source.view/index.html
+++ b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/source.view/index.html
@@ -1,5 +1,5 @@
 <!doctype html>
-<html lang="en">
+<html>
 
 <head>
   <meta charset="UTF-8">
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/task.md b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/task.md
index 0dd55b7ea2..d5671b6953 100644
--- a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/task.md
+++ b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/task.md
@@ -6,15 +6,25 @@ importance: 5
 
 编写一个函数，仅在访问者将鼠标**移动**到它上面而非**通过**它时，才会显示元素上的工具提示。
 
+<<<<<<< HEAD
 换句话说，如果访问者把鼠标移动到元素上，然后停下 —— 显示工具提示。如果访问者将鼠标快速移过元素，那就不需要显示，谁想要多余的内容呢？
+=======
+In other words, if the visitor moves the mouse on the element and stopped -- show the tooltip. And if they just moved the mouse through fast, then no need, who wants extra blinking?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 从技术上说，我们可以测量鼠标在元素上的经过速度，如果速度很慢，那么我们认为它**在元素上**并显示工具提示，如果速度太快 —— 那么我们就忽略它。
 
 为它创建一个通用对象 `new HoverIntent(options)`，加上 `options`：
 
+<<<<<<< HEAD
 - `elem` —— 要跟踪的元素。
 - `over` —— 如果鼠标缓慢地移动元素，调用该函数。
 - `out` —— 当鼠标离开元素时，调用函数（如果 `over` 被调用过了）。
+=======
+- `elem` -- element to track.
+- `over` -- a function to call if the mouse is slowly moving over the element.
+- `out` -- a function to call when the mouse leaves the element (if `over` was called).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在工具提示中使用此类对象的示例：
 
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 ec2edbb6b2..da337c23d6 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
@@ -10,15 +10,29 @@
 
 这些事件很特别，因为它们有 `relatedTarget`。
 
+<<<<<<< HEAD
 对于 `mouseover`：
 
 - `event.target` —— 是鼠标经过的那个元素。
 - `event.relatedTarget` —— 是鼠标上一次经过的元素。
+=======
+This property complements `target`. When a mouse leaves one element for another, one of them becomes `target`, and the other one `relatedTarget`.
+
+For `mouseover`:
+
+- `event.target` -- is the element where the mouse came over.
+- `event.relatedTarget` -- is the element from which the mouse came (`relatedTarget` -> `target`).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 `mouseout` 则与之相反：
 
+<<<<<<< HEAD
 - `event.target` —— 是鼠标离开的元素。
 - `event.relatedTarget` —— 是当前指针位置下的（鼠标进入的）元素。
+=======
+- `event.target` -- is the element that mouse left.
+- `event.relatedTarget` -- is the new under-the-pointer element, that mouse left for (`target` -> `relatedTarget`).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```online
 在下面示例中，每个特性都是一个元素。当你移动鼠标时你可以看到文本区域的鼠标事件。
@@ -50,7 +64,11 @@
 
 这在实践中是有用的，因为可能会有许多中间元素。我们并不是真的想要处理每一个进入离开的过程。
 
+<<<<<<< HEAD
 另一方面，我们应该记住，我们不能假设鼠标会缓慢地从一个事件移动到另一个事件。是的，它可以“跳”。
+=======
+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".
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 特别是，光标可能从窗口外跳进页面的中间。此时 `relatedTarget=null`，这是因为鼠标来自“窗口外（nowhere）”：
 
@@ -96,7 +114,11 @@
 
 因此，对于不考虑 `target` 的处理器，这看起来就像是在 `mouseout` 事件中，鼠标离开了父元素（第 `(2)` 步），然后在第 `(3)` 步的 `mouseover` 事件中鼠标又回到了父元素上。
 
+<<<<<<< HEAD
 如果我们在进入/离开元素时执行一些动作，就会多执行很多“错误”操作。对于简单的事情可能不引人注目。但对于复杂的事情来说，会带来不必要的副作用。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 我们可以通过使用 `mouseenter/mouseleave` 事件来解决这个问题。
 
@@ -169,7 +191,11 @@ table.onmouseout = function(event) {
 
 [codetabs height=380 src="mouseenter-mouseleave-delegation-2"]
 
+<<<<<<< HEAD
 尝试在表格单元之间或内部移动光标，太快或太慢都有问题。与之前不同的是只有 `<td>` 作为一个整体被高亮显示。
+=======
+Try to move the cursor in and out of table cells and inside them. Fast or slow -- doesn't matter. Only `<td>` as a whole is highlighted unlike the example before.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 
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 ea57233073..a9d76bebfd 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 6a17ca99f7..8ef27b83a4 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 babbea5027..f4b3dfe8e0 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 e61891a5af..0c95cc30c0 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 cf9fa448b1..e386c5caf3 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 a2749d68a5..a49caf310e 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 627f9584a7..975acf4aff 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 51a917d86e..50725f39cd 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/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseoverout-fast.view/index.html b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseoverout-fast.view/index.html
index 1e38d693c0..17239b026f 100755
--- a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseoverout-fast.view/index.html
+++ b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseoverout-fast.view/index.html
@@ -1,5 +1,5 @@
 <!doctype html>
-<html lang="en">
+<html>
 
 <head>
   <meta charset="UTF-8">
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 6c3daa5b23..1c1443a7e7 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 37ac3539e4..ad41368c1e 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
@@ -4,9 +4,15 @@
 
 在现代 HTML 标准中，有一个[拖动事件的部分](https://html.spec.whatwg.org/multipage/interaction.html#dnd)。
 
+<<<<<<< HEAD
 这很有趣，因为它们允许轻松地解决一些简单的任务，而且允许处理“外部”文件拖放到浏览器中的事件。因此我们可以在 OS 文件管理中获取文件，并将其拖动到浏览器窗口。然后 JavaScript 获取对其内容的访问权限。
 
 但是本地的拖动事件总是有局限性。比如，我们可以把拖动范围限制在某个区域内。而且我们也可以把它变成 "horizontal" 或 "vertical"。还有其他的拖放任务无法通过使用 API 实现。
+=======
+They are interesting because they allow to solve simple tasks easily, and also allow to handle drag'n'drop of "external" files into the browser. So we can take a file in the OS file-manager and drop it into the browser window. Then JavaScript gains access to its contents.
+
+But native Drag Events also have limitations. For instance, we can't limit dragging by a certain area. Also we can't make it "horizontal" or "vertical" only. There are other drag'n'drop tasks that can't be implemented using that API.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在这里，我们将看到如何使用鼠标事件实现拖放。并不难。
 
@@ -14,10 +20,17 @@
 
 拖放基础算法就像这样：
 
+<<<<<<< HEAD
 1. 在可拖动元素上捕获 `mousedown` 事件。
 2. 准备要移动的元素（可能创建它的副本或其他任何东西）。
 3. 然后在 `mousemove` 上，通过改变 `left/top` 和 `position:absolute` 来移动它。
 4. 在 `mouseup`（释放按钮）中 —— 执行所有完成拖放相关的动作。
+=======
+1. Catch `mousedown` on a draggable element.
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这些是基础。我们可以对其进行拓展，例如，当鼠标在可拖动元素上悬停时，高亮这个元素。
 
@@ -58,7 +71,11 @@ ball.onmousedown = function(event) { // (1) 启动进程
 };
 ```
 
+<<<<<<< HEAD
 如果我们运行代码，我们会发现一些奇怪的事情。在拖放的一开始，球会 "forks"：我们开始拖动它的 "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".
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```online
 这是一个动作实例：
@@ -101,7 +118,11 @@ ball.style.left = pageX - ball.offsetWidth / 2 + 'px';
 ball.style.top = pageY - ball.offsetHeight / 2 + 'px';
 ```
 
+<<<<<<< HEAD
 不错，但这存在副作用。我们可以在球的任何地方使用 `mousedown` 来开始拖放。如果在边缘那么做，那么球就会突然“跳”到以指针为中心的位置。
+=======
+Not bad, but there's a side-effect. To initiate the drag'n'drop, we can `mousedown` anywhere on the ball. But if do it at the edge, then the ball suddenly "jumps" to become centered.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 如果我们保持元素相对指针的初始位移，情况会更好。
 
@@ -178,7 +199,11 @@ In action (inside `<iframe>`):
 [iframe src="ball3" height=230]
 ```
 
+<<<<<<< HEAD
 如果我们按在球的右下角进行拖动，这种差异就会特别明显。在前面的示例中，球在指针下“跳动”。现在，它从当前位置跟随鼠标会很流畅。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## 检测是否可释放
 
diff --git a/2-ui/3-event-details/5-keyboard-events/2-check-sync-keydown/solution.view/index.html b/2-ui/3-event-details/5-keyboard-events/2-check-sync-keydown/solution.view/index.html
index 3ceb089c70..6e86d2455f 100644
--- a/2-ui/3-event-details/5-keyboard-events/2-check-sync-keydown/solution.view/index.html
+++ b/2-ui/3-event-details/5-keyboard-events/2-check-sync-keydown/solution.view/index.html
@@ -23,7 +23,7 @@
         // JavaScript does not get the "keyup" event
         // and pressed set will keep assuming that the key is pressed
         // so, to evade "sticky" keys, we reset the status
-        // if the user wants to run the hotkey again - let him press all keys again
+        // if the user wants to run the hotkey again - let them press all keys again
         pressed.clear();
 
         func();
diff --git a/2-ui/3-event-details/5-keyboard-events/article.md b/2-ui/3-event-details/5-keyboard-events/article.md
index 3ca19d90e0..e24f1685b6 100644
--- a/2-ui/3-event-details/5-keyboard-events/article.md
+++ b/2-ui/3-event-details/5-keyboard-events/article.md
@@ -75,6 +75,7 @@
 
 比方说，我们想要处理一个热键：`key:Ctrl+Z`（或 Mac 上的 `key:Cmd+Z`）。大多数文本编辑器将“撤销”动作挂在上面。我们可以在 `keydown` 上设置一个监听者，检查哪个键被按下 —— 用来检测我们什么时候需要热键。
 
+<<<<<<< HEAD
 请回答问题 —— 在这样的监听者中，我们要监测的是 `event.key` 还是 `event.code` 的值？
 
 请暂停并回答。
@@ -82,6 +83,13 @@
 决定好了么？
 
 如果你已经理解了，那么答案当然是 `event.code`，因为在那里我们不想要 `event.key`。`event.key` 的值会因为语言的不同或者 `CapsLock` 的使用而改变。`event.code` 的值被严格绑定到秘钥上，因此我们现在开始：
+=======
+There's a dilemma here: in such a listener, should we check the value of `event.key` or `event.code`?
+
+On one hand, the value of `event.key` changes depending on the language. If the visitor has several languages in OS and switches between them, the same key gives different characters. So it makes sense to check `event.code`, it's always the same.
+
+Like this:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 document.addEventListener('keydown', function(event) {
@@ -91,11 +99,38 @@ document.addEventListener('keydown', function(event) {
 });
 ```
 
+<<<<<<< HEAD
 ## 自动重复
 
 如果按键时间足够长，它就会开始重复：`keydown` 会被一次又一次触发，并且当它释放时我们终于得到 `keyup`。所以有很多的 `keydown` 却只有一个 `keyup` 很正常。
 
 对于所有的重复键，事件对象的 `event.repeat` 属性都设置为 `true`。
+=======
+On the other hand, there's a problem with `event.code`. For different keyboard layouts, the same key may have different labels (letters).
+
+For example, here are US layout ("QWERTY") and German layout ("QWERTZ") under it (courtesy of Wikipedia):
+
+![](us-layout.png)
+
+![](german-layout.png)
+
+For the same key, US layout has "Z", while German layout has "Y" (letters are swapped).
+
+So, `event.code` will equal `KeyZ` for people with German layout when they press "Y".
+
+That sounds odd, but so it is. The [specification](https://www.w3.org/TR/uievents-code/#table-key-code-alphanumeric-writing-system) explicitly mentions such behavior.
+
+- `event.code` has the benefit of staying always the same, bound to the physical key location, even if the visitor changes languages. So hotkeys that rely on it work well even in case of a language switch.
+- `event.code` may match a wrong character for unexpected layout. Same letters in different layouts may map to different physical keys, leading to different codes. That happens for several codes, e.g. `keyA`, `keyQ`, `keyZ` (as we've seen). You can find the list in the [specification](https://www.w3.org/TR/uievents-code/#table-key-code-alphanumeric-writing-system).
+
+So, to reliably track layout-dependent characters, `event.key` may be a better way.
+
+## Auto-repeat
+
+If a key is being pressed for a long enough time, it starts to "auto-repeat": the `keydown` triggers again and again, and then when it's released we finally get `keyup`. So it's kind of normal to have many `keydown` and a single `keyup`.
+
+For events triggered by auto-repeat, the event object has `event.repeat` property set to `true`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 
 ## 默认动作
@@ -123,7 +158,11 @@ function checkPhoneKey(key) {
 <input *!*onkeydown="return checkPhoneKey(event.key)"*/!* placeholder="Phone, please" type="tel">
 ```
 
+<<<<<<< HEAD
 请注意，像 `key:Backspace`、`key:Left`、`key:Right`、`key:Ctrl+V` 这样的特殊键在输入中无效。这是严格过滤器 `checkPhoneKey` 的副作用。
+=======
+Please note that special keys like `key:Backspace`, `key:Left`, `key:Right`, `key:Ctrl+V` do not work in the input. That's a side-effect of the strict filter `checkPhoneKey`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 让我们放松一下：
 
@@ -146,10 +185,15 @@ function checkPhoneKey(key) {
 
 在过去，有一个 `keypress` 事件，还有事件对象属性 `keyCode`、`charCode` 和 `which`。
 
+<<<<<<< HEAD
 大多数的浏览器都不兼容，以至于开发者决定放弃这些。以前的代码仍然可以正常工作，因为浏览器还是支持它们的，但现在没有必要再使用这些代码了。
 
 这章有包括了它们详细描述的时间。但现在我们可以忘记它们了。
+=======
+There were so many browser incompatibilities that developers of the specification decided to deprecate all of them. The old code still works, as browsers keep supporting them, but there's totally no need to use those any more.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
+There was a time when this chapter included their detailed description. But as of now it was removed and replaced with more details about the modern event handling.
 
 ## 总结
 
@@ -165,6 +209,10 @@ function checkPhoneKey(key) {
 - `code` —— “按键代码”（`"KeyA"`、`"ArrowLeft"` 等），具体到键盘上键的物理位置。
 - `key` —— 非字符键的字符（`"A"`、`"a"` 等），通常具有和 `code` 一样的值。
 
+<<<<<<< HEAD
 过去，键盘事件有时用于跟踪用户在表单字段中的输入。这很不可靠，因为输入源可以不同。我们有 `input` 和 `change` 事件来处理任何输入（之后我们会在 <info:events-change-input> 章节中作进一步介绍）。它们在任何输入后触发，包括鼠标或语音识别。
+=======
+In the past, keyboard events were sometimes used to track user input in form fields. That's not reliable, because the input can come from various sources. We have `input` and `change` events to handle any input (covered later in the chapter <info:events-change-input>). They trigger after any kind of input, including copy-pasting or speech recognition.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 当我们真正想要键盘时，我们应该使用键盘事件。比如，对热键或特殊键作出反应。
diff --git a/2-ui/3-event-details/5-keyboard-events/german-layout.png b/2-ui/3-event-details/5-keyboard-events/german-layout.png
new file mode 100644
index 0000000000..7e24f254ed
Binary files /dev/null and b/2-ui/3-event-details/5-keyboard-events/german-layout.png differ
diff --git a/2-ui/3-event-details/5-keyboard-events/german-layout@2x.png b/2-ui/3-event-details/5-keyboard-events/german-layout@2x.png
new file mode 100644
index 0000000000..30f6e0d13f
Binary files /dev/null and b/2-ui/3-event-details/5-keyboard-events/german-layout@2x.png differ
diff --git a/2-ui/3-event-details/5-keyboard-events/us-layout.png b/2-ui/3-event-details/5-keyboard-events/us-layout.png
new file mode 100644
index 0000000000..a42dd80fe5
Binary files /dev/null and b/2-ui/3-event-details/5-keyboard-events/us-layout.png differ
diff --git a/2-ui/3-event-details/5-keyboard-events/us-layout@2x.png b/2-ui/3-event-details/5-keyboard-events/us-layout@2x.png
new file mode 100644
index 0000000000..fd583b74d3
Binary files /dev/null and b/2-ui/3-event-details/5-keyboard-events/us-layout@2x.png differ
diff --git a/2-ui/3-event-details/8-onscroll/1-endless-page/solution.md b/2-ui/3-event-details/8-onscroll/1-endless-page/solution.md
index ff8c2653e0..ba6baffd65 100644
--- a/2-ui/3-event-details/8-onscroll/1-endless-page/solution.md
+++ b/2-ui/3-event-details/8-onscroll/1-endless-page/solution.md
@@ -35,9 +35,15 @@ document.documentElement.getBoundingClientRect().bottom = 1500
 
 
 ```js
+<<<<<<< HEAD
 // 文档顶部在窗口 -1400 px 之上
 document.documentElement.getBoundingClientRect().top = -1400
 // 文档底部为 600 px 
+=======
+// document top is above the window 1400px
+document.documentElement.getBoundingClientRect().top = -1400
+// document bottom is below the window 600px
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 document.documentElement.getBoundingClientRect().bottom = 600
 ```
 
diff --git a/2-ui/3-event-details/8-onscroll/3-load-visible-img/task.md b/2-ui/3-event-details/8-onscroll/3-load-visible-img/task.md
index 4822abfa2e..f5133f7d56 100644
--- a/2-ui/3-event-details/8-onscroll/3-load-visible-img/task.md
+++ b/2-ui/3-event-details/8-onscroll/3-load-visible-img/task.md
@@ -4,7 +4,11 @@ importance: 4
 
 # 加载可视化图像
 
+<<<<<<< HEAD
 假设我们有一个速度较慢并希望节省自己移动流量客户。
+=======
+Let's say we have a slow-speed client and want to save their mobile traffic.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 为此，我们决定不立即显示图像，而是将其替换为占位符，如下所示：
 
diff --git a/2-ui/3-event-details/8-onscroll/article.md b/2-ui/3-event-details/8-onscroll/article.md
index 721092b292..2507cbf3b4 100644
--- a/2-ui/3-event-details/8-onscroll/article.md
+++ b/2-ui/3-event-details/8-onscroll/article.md
@@ -32,6 +32,12 @@ Current scroll = <b id="showScroll">scroll the window</b>
 - `wheel` 事件 —— 鼠标滚轮（“滚动”触控板也会生成它）。
 - `key:pageUp` 和 `key:pageDown` 的 `keydown` 事件。
 
+<<<<<<< HEAD
 有时可能会有帮助，但还有很多滚动方式，所以很难处理它们。因此，使用 CSS 让一些东西不可滚动更为可靠，比如 `overflow` 属性。
+=======
+If we add an event handler to these events and `event.preventDefault()` in it, then the scroll won't start.
+
+Sometimes that may help, but it's more reliable to use CSS to make something unscrollable, such as the `overflow` property.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 这里有几个你可以完成的练习，你也可以看它们关于 `onscroll` 的应用。
diff --git a/2-ui/3-event-details/index.md b/2-ui/3-event-details/index.md
index c30fb70645..e363e2977d 100644
--- a/2-ui/3-event-details/index.md
+++ b/2-ui/3-event-details/index.md
@@ -1,3 +1,9 @@
+<<<<<<< HEAD
 # 事件细节
 
 这里我们介绍最重要的事和它们运行的细节。
+=======
+# UI Events
+
+Here we cover most important user interface events and how to work with them.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/2-ui/4-forms-controls/1-form-elements/1-add-select-option/solution.md b/2-ui/4-forms-controls/1-form-elements/1-add-select-option/solution.md
index d07d07579a..23cfa40661 100644
--- a/2-ui/4-forms-controls/1-form-elements/1-add-select-option/solution.md
+++ b/2-ui/4-forms-controls/1-form-elements/1-add-select-option/solution.md
@@ -8,12 +8,12 @@
 
 <script>
   // 1)
-  let selectedOption = genres.options[select.selectedIndex];
+  let selectedOption = genres.options[genres.selectedIndex];
   alert( selectedOption.value );
 
   // 2)
-  let newOption = new Option("classic", "Classic");
-  select.append(newOption);
+  let newOption = new Option("Classic", "classic");
+  genres.append(newOption);
 
   // 3)
   newOption.selected = true;
diff --git a/2-ui/4-forms-controls/1-form-elements/article.md b/2-ui/4-forms-controls/1-form-elements/article.md
index 5a7fd08363..4c7ce7582a 100644
--- a/2-ui/4-forms-controls/1-form-elements/article.md
+++ b/2-ui/4-forms-controls/1-form-elements/article.md
@@ -262,7 +262,11 @@ let option = new Option("Text", "value", true, true);
 : 在该 option 所属的 `<select>` 其所对应的索引。
 
 `text`
+<<<<<<< HEAD
 : 选项的文本内容（可以被任何访问者看到）。
+=======
+: Text content of the option (seen by the visitor).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 
 ## 总结
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 5d00632b2c..1ee86a4b14 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 1997b2b360..7a36f3a877 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/solution.view/my.css b/2-ui/4-forms-controls/2-focus-blur/3-editable-div/solution.view/my.css
index 10e9ddc205..bf3d4ff6a0 100644
--- a/2-ui/4-forms-controls/2-focus-blur/3-editable-div/solution.view/my.css
+++ b/2-ui/4-forms-controls/2-focus-blur/3-editable-div/solution.view/my.css
@@ -2,7 +2,7 @@
 .edit {
   height: 150px;
   width: 400px;
-  font-family: arial;
+  font-family: sans-serif;
   font-size: 14px;
   display: block;
 }
@@ -20,6 +20,6 @@
 }
 
 .edit:focus {
-  outline: none;
   /* remove focus border in Safari */
+  outline: none;
 }
diff --git a/2-ui/4-forms-controls/2-focus-blur/3-editable-div/source.view/my.css b/2-ui/4-forms-controls/2-focus-blur/3-editable-div/source.view/my.css
index 10e9ddc205..bf3d4ff6a0 100644
--- a/2-ui/4-forms-controls/2-focus-blur/3-editable-div/source.view/my.css
+++ b/2-ui/4-forms-controls/2-focus-blur/3-editable-div/source.view/my.css
@@ -2,7 +2,7 @@
 .edit {
   height: 150px;
   width: 400px;
-  font-family: arial;
+  font-family: sans-serif;
   font-size: 14px;
   display: block;
 }
@@ -20,6 +20,6 @@
 }
 
 .edit:focus {
-  outline: none;
   /* remove focus border in Safari */
+  outline: none;
 }
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 fb926ceb87..2cb1f11914 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,10 @@ importance: 5
 
 这个 textarea（文本域）允许我们编辑 `<div>` 里的 HTML 内容。
 
+<<<<<<< HEAD
 当用户按下 `key:Enter` 键或者 `<textarea>` 失去焦点的时候，焦点会回到 `<div>`，并且 `<textarea>` 里的内容会成为 `<div>` 里的 HTML 内容。
+=======
+When the user presses `key:Enter` or it loses focus, the `<textarea>` turns back into `<div>`, and its content becomes HTML in `<div>`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 [demo src="solution"]
diff --git a/2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/solution.view/my.css b/2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/solution.view/my.css
index d7f2a4424e..8d0c3b4ec5 100644
--- a/2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/solution.view/my.css
+++ b/2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/solution.view/my.css
@@ -3,14 +3,15 @@
   margin: 0;
   padding: 0;
   display: block;
-  resize: none;
+  
   /* remove resizing handle in Firefox */
+  resize: none;
   
-  outline: none;
   /* remove outline on focus in Chrome */
+  outline: none;
   
-  overflow: auto;
   /* remove scrollbar in IE */
+  overflow: auto;
 }
 
 .edit-controls {
diff --git a/2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/solution.md b/2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/solution.md
index d111918f3b..b6fe81fd0b 100644
--- a/2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/solution.md
+++ b/2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/solution.md
@@ -1,5 +1,9 @@
 
+<<<<<<< HEAD
 我们可以使用 `mouse.onclick` 来处理点击事件，并通过 `position:fixed` 让元素“可移动”，然后使用 `mouse.onkeydown` 去处理点击方向键事件。
+=======
+We can use `mouse.onclick` to handle the click and make the mouse "moveable" with `position:fixed`, then `mouse.onkeydown` to handle arrow keys.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 唯一的缺陷是 `keydown` 仅会触发在聚焦的元素上。所以我们需要为这个元素添加 `tabindex`。因为我们不可以改变 HTML，所以我们可以使用 `mouse.tabIndex` 属性来达到这个目的。
 
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 5d6d753d31..0ef465ca6f 100644
--- a/2-ui/4-forms-controls/2-focus-blur/article.md
+++ b/2-ui/4-forms-controls/2-focus-blur/article.md
@@ -2,13 +2,21 @@
 
 当一个元素被用户点击或使用键盘上的 `key:Tab` 选中时，该元素会被聚焦。当网页加载时 HTML `autofocus` 属性也可以让一个焦点落在元素上，不仅如此，还有其它途径可以获取焦点。
 
+<<<<<<< HEAD
 聚焦通常表示：“这里准备好接受数据了”，而这也正是我们运行代码去初始化或加载一些东西的时候。
+=======
+Focusing on an element generally means: "prepare to accept the data here", so that's the moment when we can run the code to initialize the required functionality.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 失去焦点的时刻可能更为重要。它可能发生在用户点击网页其它地方或者点击 `key:Tab` 跳转到下一个表单域，亦或是其它途径的时候。
 
 失去焦点通常表示：“数据已经完成输入了”，所以我们可以运行代码来检查它，甚至可以是保存到服务器上。
 
+<<<<<<< HEAD
 当操作聚焦事件的时候有一些重要的特性需要注意。我们会尽量在这里介绍。
+=======
+There are important peculiarities when working with focus events. We'll do the best to cover them further on.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## focus/blur 事件
 
@@ -49,7 +57,11 @@ Your email please: <input type="email" id="input">
 </script>
 ```
 
+<<<<<<< HEAD
 在现代的 HTML 中，可以使用 `required`、`pattern` 等诸多输入属性校验表单输入内容，并且这些属性在很多时候满足了我们的使用需求。JavaScript 可以让我们以更灵活的方式去实现。如果数据是正确的，我们可以把它自动发送到服务器上。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 
 ## focus/blur 方法
@@ -100,7 +112,11 @@ Your email please: <input type="email" id="input">
 
 有时候这些特性导致发生的 `focus/blur` 事件处理器会让人苦恼 — 它们在不被需要的时候发生。
 
+<<<<<<< HEAD
 最好的秘诀就是当使用这些事件的时候小心点。如果我们想要追踪用户发起的去焦事件，那么我们自己应该避免去触发它们。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 ```
 ## 允许在任何元素上聚焦：tabindex
 
@@ -203,7 +219,6 @@ Click the first item and press Tab. Keep track of the order. Please note that ma
 
 <script>
 *!*
-  // put the handler on capturing phase (last argument true)
   form.addEventListener("focusin", () => form.classList.add('focused'));
   form.addEventListener("focusout", () => form.classList.remove('focused'));
 */!*
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 63f5cc003a..1211e06390 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,11 @@
 
 [change](http://www.w3.org/TR/html5/forms.html#event-input-change) 事件是在元素变化结束之后触发的。
 
+<<<<<<< HEAD
 对于文本输入框来说，当其失去焦点的时候就会触发 change 事件。
+=======
+For text inputs that means that the event occurs when it loses focus.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 例如，当我们在下面的文本区域中输入的时候，`change` 事件不会被触发。但是当我们将焦点移到别处时，例如点击按钮，就会触发 `change` 事件：
 
@@ -62,7 +66,11 @@
 </script>
 ```
 
+<<<<<<< HEAD
 从技术上来讲，我们可以拷贝/粘贴任何东西。例如，我们可以从资源管理器中拷贝一份文件，然后粘贴进来。
+=======
+Technically, we can copy/paste everything. For instance, we can copy a file in the OS file manager, and paste it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在[设计规范](https://www.w3.org/TR/clipboard-apis/#dfn-datatransfer)中有一系列的方法，可以作用于不同的数据类型，对剪贴板进行读写。
 
diff --git a/2-ui/4-forms-controls/4-forms-submit/1-modal-dialog/task.md b/2-ui/4-forms-controls/4-forms-submit/1-modal-dialog/task.md
index f2d7fbcf84..d9836c4ca6 100644
--- a/2-ui/4-forms-controls/4-forms-submit/1-modal-dialog/task.md
+++ b/2-ui/4-forms-controls/4-forms-submit/1-modal-dialog/task.md
@@ -6,8 +6,13 @@ importance: 5
 
 创建一个函数 `showPrompt(html, callback)`，展示一个表单，里面有消息 `html`、一个文本输入框和 `OK/CANCEL` 按钮。
 
+<<<<<<< HEAD
 - 让用户在文本输入框中输入一些东西，然后按下 `key:Enter` 回车键或者点击 OK 按钮，然后 `callback(value)` 就会被调用，参数是输入的值。
 - 另外，如果用户按下 `key:Esc` 按键或者点击 CANCEL 按钮，那么 `callback(null)` 就会被调用。
+=======
+- A user should type something into a text field and press `key:Enter` or the OK button, then `callback(value)` is called with the value they entered.
+- Otherwise if the user presses `key:Esc` or CANCEL, then `callback(null)` is called.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 在这两种情况下，都结束了输入过程并移除了表单。
 
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 50%
rename from 2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
rename to 2-ui/5-loading/01-onload-ondomcontentloaded/article.md
index be2c7433b1..5b7fd4a9b5 100644
--- a/2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
+++ b/2-ui/5-loading/01-onload-ondomcontentloaded/article.md
@@ -1,16 +1,33 @@
+<<<<<<< HEAD:2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
 # 页面生命周期：DOMContentLoaded、load、beforeunload 和 unload
+=======
+# Page: DOMContentLoaded, load, beforeunload, unload
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/5-loading/01-onload-ondomcontentloaded/article.md
 
 HTML 页面的生命周期有三个重要事件：
 
+<<<<<<< HEAD:2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
 - `DOMContentLoaded` —— 浏览器加载 HTML，并构建 DOM 树，但像 `<img>` 和样式这样的资源可能还没有加载。
 - `load` —— 浏览器加载所有资源（图像，样式等）。
 - `beforeunload/unload` —— 当用户离开页面时。
+=======
+- `DOMContentLoaded` -- the browser fully loaded HTML, and the DOM tree is built, but external resources like pictures `<img>` and stylesheets may be not yet loaded.  
+- `load` -- not only HTML is loaded, but also all the external resources: images, styles etc.
+- `beforeunload/unload` -- the user is leaving the page.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/5-loading/01-onload-ondomcontentloaded/article.md
 
 每个事件都是有用的：
 
+<<<<<<< HEAD:2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
 - `DOMContentLoaded` 事件 —— DOM 已经准备好，因此处理器可以查找 DOM 节点，并初始化接口。
 - `load` 事件 —— 额外资源被加载后，我们可以获取图像大小（如果在 HTML/CSS 中没有指定）等。
 - `beforeunload/unload` 事件 —— 用户即将离开：我们可以检查用户是否保存了修改，并在询问他是否真的要离开。
+=======
+- `DOMContentLoaded` event -- DOM is ready, so the handler can lookup DOM nodes, initialize the interface.
+- `load` event -- external resources are loaded, so styles are applied, image sizes are known etc.
+- `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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/5-loading/01-onload-ondomcontentloaded/article.md
 
 我们探讨一下这些事件的细节。
 
@@ -22,6 +39,7 @@ HTML 页面的生命周期有三个重要事件：
 
 ```js
 document.addEventListener("DOMContentLoaded", ready);
+// not "document.onDOMContentLoaded = ..."
 ```
 
 例如：
@@ -43,12 +61,21 @@ document.addEventListener("DOMContentLoaded", ready);
 <img id="img" src="https://en.js.cx/clipart/train.gif?speed=1&cache=0">
 ```
 
+<<<<<<< HEAD:2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
 在示例中，`DOMContentLoaded` 处理器在文档加载时运行，而不是等到页面被加载时运行。因此 `alert` 显示大小为零。
 
 初识 `DOMContentLoaded` 事件时，觉得它比较简单。DOM 树已经准备好了 —— 这是事件。但却没有什么特别之处。
+=======
+In the example the `DOMContentLoaded` handler runs when the document is loaded, so it can see all the elements, including `<img>` below.
+
+But it doesn't wait for the image to load. So `alert` shows zero sizes.
+
+At the first sight `DOMContentLoaded` event is very simple. The DOM tree is ready -- here's the event. There are few peculiarities though.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/5-loading/01-onload-ondomcontentloaded/article.md
 
 ### DOMContentLoaded 和脚本
 
+<<<<<<< HEAD:2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
 当浏览器开始加载 HTML 并在文本中遇到 `<script>...</script>` 时，就会停止构建 DOM。它必须立即执行脚本。因此 `DOMContentLoaded` 只有在所有此类脚本被执行后才会发生。
 
 额外的脚本（带有 `src`）也会促使 DOM 构建在加载和执行过程时暂停。因此 `DOMContentLoaded` 也会等待外部脚本。
@@ -68,14 +95,46 @@ document.addEventListener("DOMContentLoaded", ready);
 | `DOMContentLoaded` | 具有 `async` 的脚本可以在文档尚未完全下载时加载和执行。如果脚本较小或被缓存，而且文档足够长，就会发生这种情况。 | 在 `DOMContentLoaded` 之前，具有 `defer` 的脚本会在文档被加载并解析后执行（如果需要，它们会等待）。 |
 
 因此 `async` 用于完全独立的脚本。
+=======
+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.
+
+So DOMContentLoaded definitely happens after such scripts:
+
+```html run
+<script>
+  document.addEventListener("DOMContentLoaded", () => {
+    alert("DOM ready!");
+  });
+</script>
+
+<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.3.0/lodash.js"></script>
+
+<script>
+  alert("Library loaded, inline script executed");
+</script>
+```
 
+In the example above, we first see "Library loaded...", and then "DOM ready!" (all scripts are executed).
+
+```warn header="Scripts with `async`, `defer` or `type=\"module\"` don't block DOMContentLoaded"
+
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/5-loading/01-onload-ondomcontentloaded/article.md
+
+So here we're talking about "regular" scripts, like `<script>...</script>`, or `<script src="..."></script>`.
 ```
 
 ### DOMContentLoaded 和样式
 
+<<<<<<< HEAD:2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
 外部样式不会影响 DOM，因此 `DOMContentLoaded` 无需等待它们。
 
 但有一个陷阱：如果在样式之后有一个脚本，那么该脚本必须等待样式被执行：
+=======
+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 until the stylesheet loads:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/5-loading/01-onload-ondomcontentloaded/article.md
 
 ```html
 <link type="text/css" rel="stylesheet" href="style.css">
@@ -97,7 +156,10 @@ Firefox、Chrome 和 Opera 都会在 `DOMContentLoaded` 中自动填写表单。
 
 因此如果 `DOMContentLoaded` 被长加载脚本延迟，那么自动填写也在等待。你可能在某些站点上（如果你使用浏览器自动填写）—— 登录/密码字段将不会立即自动填写，在页面被完全加载前会出现延迟。这实际上是延迟到 `DOMContentLoaded` 事件。
 
+<<<<<<< HEAD:2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
 为外部脚本使用 `async` 和 `defer` 的一个好处是 —— 它们不会阻塞 `DOMContentLoaded`，而且也不会延迟浏览器的自动填写。
+=======
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/5-loading/01-onload-ondomcontentloaded/article.md
 
 ## window.onload [#window-onload]
 
@@ -120,39 +182,98 @@ Firefox、Chrome 和 Opera 都会在 `DOMContentLoaded` 中自动填写表单。
 
 ## window.onunload
 
+<<<<<<< HEAD:2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
 当访问者离开页面时，`unload` 事件会在 `window` 上被触发。我们可以在那里做一些不涉及延迟的事件，比如关闭相关的弹出窗口。但我们不能取消跳转到另一个页面的事件。
 
 因此我们需要使用另一个事件 —— `onbeforeunload`。
+=======
+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.
+
+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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/5-loading/01-onload-ondomcontentloaded/article.md
 
 ## window.onbeforeunload [#window.onbeforeunload]
 
 如果访问中启动了离开页面的导航或试图关闭窗口，`beforeunload` 处理器将要求提供更多的确认。
 
+<<<<<<< HEAD:2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
 它可能会返回一个带有问题的字符串。从历史上看，浏览器通常会显示它，但到目前为止，只有一些浏览器这样做。这是因为某些站长滥用了这个事件处理器，显示了误导和恶意的信息。
 
 你可以通过运行这段代码，然后重新加载页面来进行尝试。
+=======
+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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/5-loading/01-onload-ondomcontentloaded/article.md
 
 ```js run
 window.onbeforeunload = function() {
-  return "There are unsaved changes. Leave now?";
+  return false;
 };
 ```
 
+<<<<<<< HEAD:2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
 ```online
 你也可以单击以下 `<iframe>` 中的按钮来设置处理器，然后单击链接：
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/5-loading/01-onload-ondomcontentloaded/article.md
+
+Here's an example:
 
-[iframe src="window-onbeforeunload" border="1" height="80" link edit]
+```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
 
 如果在加载文档之后设置 `DOMContentLoaded` 处理器会发生什么？
 
 很自然地，它从未运行过。
 
+<<<<<<< HEAD:2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
 在某些情况下，我们不确定文档是否已经准备就绪，比如一个具有 `async` 属性的脚本加载并异步运行。取决于网络，它可能在文档完成之前加载和执行，或者在此之后，我们无法确定。因此，我们应该能够知道文件的当前状态。
 
 `document.readyState` 属性为我们提供了一些关于它的信息。有三个可能的值：
+=======
+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.
+
+There are 3 possible values:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/5-loading/01-onload-ondomcontentloaded/article.md
 
 - `"loading"` —— 文档正在被加载。
 - `"interactive"` —— 文档被全部读取。
@@ -166,13 +287,19 @@ window.onbeforeunload = function() {
 function work() { /*...*/ }
 
 if (document.readyState == 'loading') {
+  // loading yet, wait for the event
   document.addEventListener('DOMContentLoaded', work);
 } else {
+  // DOM is ready!
   work();
 }
 ```
 
+<<<<<<< HEAD:2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
 有一个 `readystatechange` 事件，当状态发生变化时触发，因此我们可以打印如下所有这些状态：
+=======
+There's also `readystatechange` event that triggers when the state changes, so we can print all these states like this:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/5-loading/01-onload-ondomcontentloaded/article.md
 
 ```js run
 // current state
@@ -182,15 +309,22 @@ console.log(document.readyState);
 document.addEventListener('readystatechange', () => console.log(document.readyState));
 ```
 
+<<<<<<< HEAD:2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
 `readystatechange` 事件是跟踪文档加载状态的另一种机制，它很早就存在了。现在则很少被使用，但我们还是需要来讨论一下它的完整性。
 
 `readystatechange` 在其他事件中的地位？
 
 要查看时间，这里有一个带有 `<iframe>`、`<img>` 和记录事件的处理器：
+=======
+The `readystatechange` event is an alternative mechanics of tracking the document loading state, it appeared long ago. Nowadays, it is rarely used.
+
+Let's see the full events flow for the completeness.
+
+Here's a document with `<iframe>`, `<img>` and handlers that log events:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/5-loading/01-onload-ondomcontentloaded/article.md
 
 ```html
 <script>
-  function log(text) { /* output the time and message */ }
   log('initial readyState:' + document.readyState);
 
   document.addEventListener('readystatechange', () => log('readyState:' + document.readyState));
@@ -214,18 +348,26 @@ document.addEventListener('readystatechange', () => console.log(document.readySt
 2. [2] readyState:interactive
 3. [2] DOMContentLoaded
 4. [3] iframe onload
-5. [4] readyState:complete
-6. [4] img onload
+5. [4] img onload
+6. [4] readyState:complete
 7. [4] window onload
 
+<<<<<<< HEAD:2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
 方括号中的数字表示发生这种情况的大致时间。实际时间会长一些，但标记为相同数字的事件几乎是同时发生的（+- 几毫秒）。
 
 - `document.readyState` 在 `DOMContentLoaded` 之前会立即变成了 `interactive`。这两个事件的意义没有任何差别。
 - 当所有资源（`iframe` 和 `img`）都被加载后，`document.readyState` 变成了 `complete`。这里我们可以发现，它大约发生在 `img.onload` (`img` 是最后的资源) 和 `window.onload` 之间。转换到 `complete` 状态的意义与 `window.onload` 一致。区别在于 `window.onload` 在所有其他 `load` 处理器之后一直有效。
+=======
+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 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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/5-loading/01-onload-ondomcontentloaded/article.md
 
 
 ## 总结
 
+<<<<<<< HEAD:2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
 页面生命周期事件：
 
 - 当 DOM 准备就绪时，`DOMContentLoaded` 事件就会在 `document` 上触发。在这个阶段，我们可以将 JavaScript 应用于元素。
@@ -238,3 +380,17 @@ document.addEventListener('readystatechange', () => console.log(document.readySt
   - `loading` —— 文档正在被加载。
   - `interactive` —— 文档被解析，大概是与 `DOMContentLoaded` 同时发生，而不是在它之前发生。
   - `complete` —— 文档和资源被加载，与 `window.onload` 同时发生，而不是在它之前发生。
+=======
+Page load events:
+
+- `DOMContentLoaded` event triggers on `document` when DOM is ready. We can apply JavaScript to elements at this stage.
+  - 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 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.
+  - `complete` -- the document and resources are loaded, happens at about the same time as `window.onload`, but before it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/5-loading/01-onload-ondomcontentloaded/article.md
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 0000000000..b3e4892b3f
--- /dev/null
+++ b/2-ui/5-loading/02-script-async-defer/article.md
@@ -0,0 +1,195 @@
+
+# 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 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 use far-from-perfect mobile internet.
+
+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 defer src="https://javascript.info/article/script-async-defer/long.js"></script>
+<script defer 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 requires 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>` tag has no `src`.
+```
+
+
+## async
+
+The `async` attribute means that a script is completely independent:
+
+- 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 independent third-party script into the page: counters, ads and so on, as they don't depend on our scripts, and our scripts shouldn't wait for them:
+
+```html
+<!-- Google Analytics is usually added like this -->
+<script async src="https://google-analytics.com/analytics.js"></script>
+```
+
+
+## Dynamic scripts
+
+We can also add 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 (just like regular scripts) by explicitly setting `async` property 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 the whole DOM and/or their relative execution order is important. And  `async` is used for independent scripts, like counters or ads. 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 0000000000..48710f1c62
--- /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 0000000000..ec743a025d
--- /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/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 77%
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 2e22e58c93..c55c82c786 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,11 @@ importance: 4
 
 # 用回调函数加载 images
 
+<<<<<<< HEAD:2-ui/3-event-details/11-onload-onerror/1-load-img-callback/task.md
 通常，图像在被创建时就会被加载，因此当我们在页面中添加 `<img>` 时，用户不会立即看到图像。浏览器首先会加载它。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:2-ui/5-loading/03-onload-onerror/1-load-img-callback/task.md
 
 我们可以像这样“提前”创建来立即显示图像：
 
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 0000000000..56b8165b63
--- /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 occurred 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="/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 depending 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 0000000000..a7ac6ef5a5
--- /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 0000000000..9e01193d32
--- /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 5df005c3cc..0000000000
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 990ecac3ea..0000000000
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 636c2abec1..0000000000
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 86e8f80ef1..0000000000
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 1fdc08f766..0000000000
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 e60ced0dee..0000000000
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 cbad0a367f..0000000000
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 6dbf1bfd83..0000000000
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 177af24758..0000000000
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 badd242dfb..0000000000
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 f27ebcd76c..0000000000
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 129eb36e2c..0000000000
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 f5b9e6284a..0000000000
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 bc4da5f764..0000000000
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 53d42f1d09..0000000000
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 80fef73285..0000000000
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 1761ce21e6..0000000000
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 b21b886982..0000000000
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 9176f973fd..0000000000
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 f4e8d790bc..0000000000
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 91e2bfe582..0000000000
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 31384e53d9..0000000000
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 795e4cdf4d..0000000000
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 95ec3cf913..0000000000
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 bd48229072..0000000000
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 8dad7cc346..0000000000
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 50ed8a7bb6..0000000000
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 067ad9baef..0000000000
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 e00c52c45f..0000000000
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 14207250c3..0000000000
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 b95ce55054..0000000000
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 df4cca89dc..0000000000
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 2d4d91cdd2..0000000000
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 49eeb9606b..0000000000
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 213ed84a63..0000000000
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 4d8d698dad..0000000000
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 c63bc9d958..0000000000
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 794f162354..0000000000
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 795e4cdf4d..0000000000
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 95ec3cf913..0000000000
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 af1e90d762..0000000000
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 1c558f469c..0000000000
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 657942f736..0000000000
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 9f68a73f26..0000000000
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 cdb43f7988..0000000000
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 7d1c7ced90..0000000000
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 f18ffbdca2..0000000000
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 2dbd6d3cf5..0000000000
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 9d29ec1bd6..0000000000
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 e10b7fef8d..0000000000
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 670715a7f3..0000000000
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 9a3ca207bb..0000000000
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 35c06319a4..0000000000
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 d3477022aa..0000000000
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 76%
rename from 4-frames-and-windows/01-popup-windows/article.md
rename to 3-frames-and-windows/01-popup-windows/article.md
index f9a9e6bffb..3ef8eb8532 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 @@
 
 基本上，你只需要执行：
 ```js
-window.open('http://javascript.info/')
+window.open('https://javascript.info/')
 ```
 
 ... 它将打开一个给定 URL 的新窗口。大多数的现代浏览器都配置为打开新的选项卡而不是单独的窗口。
@@ -13,11 +13,32 @@ window.open('http://javascript.info/')
 
 弹窗在很久之前就存在。最初的想法是在不关闭主窗口的情况下显示额外的内容。到目前为止，还有其他的方式可以实现这一点：JavaScript 可以向服务器发送请求，所以很少使用弹窗了。但有些时候他们依然很方便。
 
+<<<<<<< HEAD:4-frames-and-windows/01-popup-windows/article.md
 在过去很多恶意网站滥用弹窗。一个恶意页面可能会打开大量带有广告的弹窗。所以现在大多数浏览器都会通过阻止弹窗来保护用户。
+=======
+In the past, evil sites abused popups a lot. A bad page could open tons of popup windows with ads. So now most browsers try to block popups and protect the user.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/01-popup-windows/article.md
 
 **如果在用户触发的事件处理函数（如`onclick`）之外调用它们，大多数浏览器会阻止弹窗**
 
+<<<<<<< HEAD:4-frames-and-windows/01-popup-windows/article.md
 如果你仔细想一想，这就有些棘手了。如果代码是直接绑定到 `onclick` 的处理函数上，那就很简单。但是在 `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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/01-popup-windows/article.md
 
 试试这段代码：
 
@@ -28,7 +49,11 @@ setTimeout(() => window.open('http://google.com'), 3000);
 
 弹窗在 Chrome 中会打开，但是在 Firefox 被阻止。
 
+<<<<<<< HEAD:4-frames-and-windows/01-popup-windows/article.md
 ...而这段代码在 Firefox 又有效果：
+=======
+...If we decrease the delay, the popup works in Firefox too:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/01-popup-windows/article.md
 
 ```js run
 // open after 1 seconds
@@ -39,6 +64,7 @@ setTimeout(() => window.open('http://google.com'), 1000);
 
 ## 现代用法
 
+<<<<<<< HEAD:4-frames-and-windows/01-popup-windows/article.md
 到目前位置，我们有很多方法可以使用 JavaScript 加载和显示页面上的数据。但是仍然有弹窗表现更好的情况。
 
 例如，许多购物网站为咨询的人们提供在线聊天。访问者点击按钮，就会执行 `window.open` 并打开聊天弹窗。
@@ -48,6 +74,13 @@ setTimeout(() => window.open('http://google.com'), 1000);
 1. 弹窗是一个独立的窗口，具有自己独立的 JavaScript 运行环境。因此，聊天服务不需要和主要的购物网站的脚本集成在一起。
 2. 弹窗很容易附加到网站，几乎没有开销。只需要一个小按钮，不需要额外的脚本。
 3. 即使用户离开页面，弹窗依然可以存在。例如，一个咨询建议的用户访问了一个新的 “Super-Cooler” 活动页。用户从主窗口进入新页面，而不用退出聊天。
+=======
+As of now, we have many methods to load and show data on-page with JavaScript. But there are still situations when a popup works good, because:
+
+1. A popup is a separate window with its own independent JavaScript environment. So opening a popup with a third-party non-trusted site is safe.
+2. It's very easy to open a popup, little to no overhead. 
+3. A popup may persist even if the user left the page. In also can navigate (change URL) in the opener window.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/01-popup-windows/article.md
 
 ## window.open
 
@@ -103,10 +136,17 @@ open('/', 'test', params);
 
 省略设置的规则：
 
+<<<<<<< HEAD:4-frames-and-windows/01-popup-windows/article.md
 - 如果 `open` 调用中没有第三个参数，或者它是空的，则使用默认的窗口参数。
 - 如果存在参数字符串，但是省略了某些 yes/no 的特性，那么如果浏览器允许，则禁用省略的特性。因此，如果指定参数，请确保将所有必需的特性明确设置为 yes。
 - 如果参数中没有 `left/top`，则浏览器会尝试在最后打开的窗口附近打开一个新窗口。
 - 如果没有“宽度/高度”，则新窗口的大小与上次打开的大小相同。
+=======
+- If there is no 3rd argument in the `open` call, or it is empty, then the default window parameters are used.
+- If there is a string of params, but some `yes/no` features are omitted, then the omitted features assumed to have `no` value. So if you specify params, make sure you explicitly set all required features to yes.
+- If there is no `left/top` in params, then the browser tries to open a new window near the last opened window.
+- If there is no `width/height`, then the new window will be the same size as the last opened.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/01-popup-windows/article.md
 
 ## 访问弹窗
 
@@ -174,8 +214,13 @@ window.onblur = () => window.focus();
 
 例如：
 
+<<<<<<< HEAD:4-frames-and-windows/01-popup-windows/article.md
 - 当我们打开弹窗时，在它上面执行 `newWindow.focus()` 可能是个好主意。为了以防万一，对于某些 OS/浏览器组合，它确保用户现在处于新窗口中。
 - 如果我们想要跟踪访问者何时在实际使用我们的网页应用，我们可以跟踪 `window.onfocus/onblur`。这允许我们在暂停/恢复页面活动，动画等。但是请注意，`blur` 事件意味着访问者从窗口切换出来，但他仍然可以观察它。窗口在后台，但仍有可能是可见的。
+=======
+- When we open a popup, it's might be a good idea to run a `newWindow.focus()` on it. Just in case, for some OS/browser combinations it ensures that the user is in the new window now.
+- If we want to track when a visitor actually uses our web-app, we can track `window.onfocus/onblur`. That allows us to suspend/resume in-page activities, animations etc. But please note that the `blur` event means that the visitor switched out from the window, but they still may observe it. The window is in the background, but still may be visible.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/01-popup-windows/article.md
 
 ## 总结   
 
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 74%
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 17a2b5d250..e3f21a3805 100644
--- a/4-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -1,8 +1,14 @@
 # 跨窗口通信
 
+<<<<<<< HEAD:4-frames-and-windows/03-cross-window-communication/article.md
 "同源"策略限制了窗口之间的互相访问。
 
 这个想法出于这样的考虑，如果我们打开了两个窗口：一个窗口来自 `john-smith.com`，另一个是 `gmail.com`，那么我们就不希望 `john-smith.com` 的脚本可以阅读我们的邮件。
+=======
+The "Same Origin" (same site) policy limits access of windows and frames to each other.
+
+The idea is that if a user has two pages open: one from `john-smith.com`, and another one is `gmail.com`, then they wouldn't want a script from `john-smith.com` to read our mail from `gmail.com`. So, the purpose of the "Same Origin" policy is to protect users from information theft.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/03-cross-window-communication/article.md
 
 ## 同源
 
@@ -21,6 +27,7 @@
 - <code><b>https://</b>site.com</code> (协议与其他不同: `https`)
 - <code>http://site.com:<b>8080</b></code> (端口与其他不同：`8080`)
 
+<<<<<<< HEAD:4-frames-and-windows/03-cross-window-communication/article.md
 如果我们有另外一个窗口（一个弹出窗口或者 iframe）的引用，并且这个窗口是同源的，那么我们可以使用它做任何事情。
 
 如果它不是同源的，那么我们只能改变它的地址。请注意：不是**读取**地址，而是**改变**它，将其重定向到另外一个地址。因为 URL 可能包含一些敏感的参数，所以为了安全，禁止从一个非同源的站点获取地址，但是可以更改它。
@@ -34,19 +41,43 @@
 如果窗口有相同的二级域名，比如 `john.site.com`，`peter.site.com` 和 `site.com`，我们可以使用 JavaScript 将 `document.domain` 设置为他们相同的二级域名 `site.com`。此时这些窗口将被当做同源的站点对待。
 
 换句话说，所有的这些页面（包括来自 `site.com` 的页面）都添加这么一段代码：
+=======
+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 cannot *read* location (so we can't see where the user is now, no information leak).
+
+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"
+There's a small exclusion in the "Same Origin" policy.
+
+If windows share the same second-level domain, for instance `john.site.com`, `peter.site.com` and `site.com` (so that their common second-level domain is `site.com`), they can be treated as coming from the "same origin".
+
+To make it work, all such pages (including the one from `site.com`) should run the code:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/03-cross-window-communication/article.md
 
 ```js
 document.domain = 'site.com';
 ```
 
+<<<<<<< HEAD:4-frames-and-windows/03-cross-window-communication/article.md
 之后他们就可以无限制的互动了。
 
 但是这仅适用于具有相同二级域名的页面。
+=======
+That's all. Now they can interact without limitations. Again, that's only possible for pages with the same second-level domain.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/03-cross-window-communication/article.md
 ````
 
 ## 访问 iframe 的内容
 
+<<<<<<< HEAD:4-frames-and-windows/03-cross-window-communication/article.md
 一个 `<iframe>` 是一个两面派的野兽。从一方面看，它就是一个标签，就像 `<script>` 或者 `<img>`，从另一方面来说，它又是一个窗口内嵌套的窗口。
+=======
+Our first example covers iframes. An `<iframe>` is a two-faced beast. From one side it's a tag, just like `<script>` or `<img>`. From the other side it's a window-in-window.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/03-cross-window-communication/article.md
 
 嵌入的窗口有它单独的 `document` 和 `window` 对象。
 
@@ -136,9 +167,13 @@ document.domain = 'site.com';
 </script>
 ```
 
+<<<<<<< HEAD:4-frames-and-windows/03-cross-window-communication/article.md
 对于新的开发者来言，这实际上是一个众所周知的陷阱。我们不应该立即使用这个 document，因为这个是错误的。我们在它上面增加的任何事件处理函数都将被忽略。
 
 ...但是只有当 iframe 内的所有资源加载完后才会触发 `onload` 事件，如果我们希望更早的在嵌入文档的 `DOMContentLoaded` 上做操作怎么办？
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/03-cross-window-communication/article.md
 
 
 如果 iframe 不是同源的，那就无法完成这件事。但是对于同源的 iframe 来说，我们可以尝试捕捉新文档出现的时机，然后设置必要的处理逻辑，如下所示：
@@ -209,7 +244,11 @@ if (window == top) { // current window == window.top?
 
 ## sandbox 属性
 
+<<<<<<< HEAD:4-frames-and-windows/03-cross-window-communication/article.md
 `sandbox` 属性允许在 `<iframe>` 中禁止某些特定操作，以避免执行一些不被信任的代码。它通过将它当做非同源的网页对待以及添加一些限制以实现 iframe 的沙盒化。
+=======
+The `sandbox` attribute allows for the exclusion of certain actions inside an `<iframe>` in order to prevent it executing untrusted code. It "sandboxes" the iframe by treating it as coming from another origin and/or applying other limitations.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/03-cross-window-communication/article.md
 
 默认情况下，对于 `<iframe sandbox src="...">`，会有一些"默认限制"被应用于 iframe。但是我们可以像 `<iframe sandbox="allow-forms allow-popups">` 这样，提供一个以空格分割的"排除"限制列表作为属性，此时被列出的限制将不会生效。
 
@@ -249,7 +288,13 @@ if (window == top) { // current window == window.top?
 
 通过 `postMessage` 这个接口，我们可以在不同源的窗口内进行通信。
 
+<<<<<<< HEAD:4-frames-and-windows/03-cross-window-communication/article.md
 它有两个部分。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/03-cross-window-communication/article.md
 
 ### postMessage
 
@@ -355,6 +400,13 @@ window.addEventListener("message", function(event) {
 - 对于二级域名相同的页面：`a.site.com` 和 `b.site.com`。通过在它们的代码里执行 `document.domain='site.com'` 可以让他们处于"同源"状态。 
 - 如果 iframe 有 `sandbox` 属性，则会强制其处于"非同源"状态，除非在属性中指定了 `allow-same-origin`，这可可用于在同一站点的 iframe 中运行不受信任的代码。
 
+<<<<<<< HEAD:4-frames-and-windows/03-cross-window-communication/article.md
+=======
+
+Exclusions are:
+- Windows that share the same second-level domain: `a.site.com` and `b.site.com`. Then setting `document.domain='site.com'` in both of them puts them into the "same origin" state.
+- If an iframe has a `sandbox` attribute, it is forcefully put into the "different origin" state, unless the `allow-same-origin` is specified in the attribute value. That can be used to run untrusted code in iframes from the same site.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/03-cross-window-communication/article.md
 
 `postMessage` 接口允许两个窗口之间进行通信（要通过安全检查）：
 
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 58%
rename from 4-frames-and-windows/06-clickjacking/article.md
rename to 3-frames-and-windows/06-clickjacking/article.md
index d49b8db845..8e494f371d 100644
--- a/4-frames-and-windows/06-clickjacking/article.md
+++ b/3-frames-and-windows/06-clickjacking/article.md
@@ -2,7 +2,11 @@
 
 “点击劫持” 攻击即允许恶意网页**以用户的名义**点击 “受害站点”。
 
+<<<<<<< HEAD:4-frames-and-windows/06-clickjacking/article.md
 许多站点都被这样攻击过，包括 Twitter、Facebook 和 Paypal 等等许多网站。当然，目前它们都已修复这个问题。
+=======
+Many sites were hacked this way, including Twitter, Facebook, Paypal and other sites. They have all been fixed, of course.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/06-clickjacking/article.md
 
 ## 原理
 
@@ -63,7 +67,11 @@ iframe { /* 来自受害网站的 iframe */
 ```smart header="点击劫持作用于点击事件，而非键盘事件"
 此攻击仅影响鼠标操作。
 
+<<<<<<< HEAD:4-frames-and-windows/06-clickjacking/article.md
 从技术上讲，可以用 iframe 中的文本域覆盖原有的文本域实现攻击。所以当访问者试图聚焦网页中的 input 标签时，实际上聚焦的是 iframe 中的 input 标签。
+=======
+Technically, if we have a text field to hack, then we can position an iframe in such a way that text fields overlap each other. So when a visitor tries to focus on the input they see on the page, they actually focus on the input inside the iframe.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/06-clickjacking/article.md
 
 但是这里有个问题。访问者的所有输入都会被隐藏，因为该 iframe 是不可见的。
 
@@ -90,7 +98,11 @@ if (top != window) {
 
 在 [beforeunload](info:onload-ondomcontentloaded#window.onbeforeunload) 事件中阻塞 `top.location` 变更过渡。
 
+<<<<<<< HEAD:4-frames-and-windows/06-clickjacking/article.md
 顶层页面（从属于黑客）在 `beforeunload` 上添加一个处理方法：当 `iframe` 试图变更 `top.location` 时，访问者会收到询问是否离开的消息。
+=======
+The top page (belonging to the hacker) sets a handler to it, and when the `iframe` tries to change `top.location` the visitor gets a message asking them whether they want to leave.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/06-clickjacking/article.md
 
 如下所示：
 ```js
@@ -100,7 +112,11 @@ window.onbeforeunload = function() {
 };
 ```
 
+<<<<<<< HEAD:4-frames-and-windows/06-clickjacking/article.md
 大多数情况下，由于并不知道 iframe 的存在，访问者看到的只是顶层页面，即本来就要访问的页面，由此认为没有必要离开，所以会回答否。则 `top.location` 并不会变化！
+=======
+In most cases the visitor would answer negatively because they don't know about the iframe - all they can see is the top page, leading them to think there is no reason to leave. So `top.location` won't change!
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/06-clickjacking/article.md
 
 作用如下：
 
@@ -140,16 +156,28 @@ window.onbeforeunload = function() {
 
 例如，Twitter 使用的是 `X-Frame-Options: SAMEORIGIN`。
 
+<<<<<<< HEAD:4-frames-and-windows/06-clickjacking/article.md
 ````online
 如下所示：
+=======
+For instance, Twitter uses `X-Frame-Options: SAMEORIGIN`.
+
+````online
+Here's the result:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/06-clickjacking/article.md
 
 ```html
 <iframe src="https://twitter.com"></iframe>
 ```
 
+<!-- ebook: prerender/ chrome headless dies and timeouts on this iframe -->
 <iframe src="https://twitter.com"></iframe>
 
+<<<<<<< HEAD:4-frames-and-windows/06-clickjacking/article.md
 取决于浏览器行为，以上 `iframe` 要么显示为空，要么提醒你浏览器不允许内部页面加载。
+=======
+Depending on your browser, the `iframe` above is either empty or alerting you that the browser won't permit that page to be navigating in this way.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/06-clickjacking/article.md
 ````
 
 ## 显示不可用功能
@@ -189,13 +217,59 @@ window.onbeforeunload = function() {
 
 [codetabs src="protector"]
 
+<<<<<<< HEAD:4-frames-and-windows/06-clickjacking/article.md
 ## 总结
+=======
+## 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
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/06-clickjacking/article.md
 
 点击劫持是一种 “欺骗” 用户在不知情下点击恶意站点的方式。如果是重要的点击操作，这是非常危险的。
 
+<<<<<<< HEAD:4-frames-and-windows/06-clickjacking/article.md
 黑客可以通过信息提交一个链接到他的恶意网页，或者通过某些手段引诱访问者访问他的网页。当然还有许多其他变体。
 
 一方面 —— 这种攻击方式是“浅层”的：黑客只需要拦截一次点击。但另一方面，如果被这次点击之后会开启另一个控制开关，那么黑客同样用狡猾的提示强制用户点击这些控制按钮。
+=======
+A hacker can post a link to their evil page in a message, or lure visitors to their page by some other means. There are many variations.
+
+From one perspective -- the attack is "not deep": all a hacker is doing is intercepting a single click. But from another perspective, if the hacker knows that after the click another control will appear, then they may use cunning messages to coerce the user into clicking on them as well.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:3-frames-and-windows/06-clickjacking/article.md
 
 这种攻击相当危险，因为在设计交互界面时，通常不会考虑到可能会有黑客代替真正的访问者点击界面。所以许多意想不到的地方可能发现攻击漏洞。
 
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 84%
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
index ec742436d3..d578a8b10b 100644
--- a/4-frames-and-windows/06-clickjacking/top-location.view/index.html
+++ b/3-frames-and-windows/06-clickjacking/top-location.view/index.html
@@ -31,9 +31,9 @@
 
 <body>
 
-  <p>After a click on the button the visitor gets a "strange" question about whether he wants to leave.</p>
+  <p>After a click on the button the visitor gets a "strange" question about whether they want to leave.</p>
 
-  <p>Probably he would respond "No", and the iframe protection is hacked.</p>
+  <p>Probably they would respond "No", and the iframe protection is hacked.</p>
 
   <button onclick="attack()">Add a "protected" iframe</button>
 
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 0000000000..2f51384efb
--- /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 0000000000..e88b1a5379
--- /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 0000000000..bcb19daef1
--- /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 0000000000..6710104b2a
--- /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 0000000000..3c9bebde57
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 0000000000..0a6e4a246b
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 0000000000..7be333e030
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 0000000000..a0b02dbb2e
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 0000000000..66a23c2518
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 0000000000..dfdd3d8846
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 0000000000..7c1f5bbba1
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 0000000000..ebaef188c5
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 0000000000..de4e719b26
--- /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 contiguous 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 `.getUint16(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 unsigned integers 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 terms, 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 0000000000..9287279ec4
--- /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 0000000000..d0d1767849
--- /dev/null
+++ b/4-binary/03-blob/article.md
@@ -0,0 +1,242 @@
+# 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/), in particular `Blob`.
+
+`Blob` consists of an optional string `type` (a MIME-type usually), plus `blobParts` -- a sequence of other `Blob` objects, strings and `BufferSources`.
+
+![](blob.png)
+
+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.
+
+Thanks to `type`, we can allso download/upload blobs, and it naturally becomes `Content-Type` in network requests.
+
+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 automatically.
+
+Here's the similar code that causes user to download the dynamicallly created Blob, without any 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 value of `link.href` 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 (and hence the link with it) is only valid within the current document, while it's open. And it allows to reference the blob in `<img>`, `<a>`, basically 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 0000000000..cd0974f494
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 0000000000..519bdf885c
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 0000000000..281ca211ff
--- /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 inherits from `Blob` and 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 data from `Blob` (and hence `File` too) objects.
+
+It delivers the data using events, 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 occurred.
+- `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 in synchronous calls, that are possible while reading from files, in Web Workers are less important. They do not affect the page.
+```
+
+## Summary
+
+`File` objects 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 0000000000..2b0c5dc825
--- /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 0000000000..783c399623
--- /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 0000000000..5a58b209b5
--- /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 0000000000..18610676a0
--- /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 0000000000..afd889fd4d
--- /dev/null
+++ b/5-network/02-fetch-progress/article.md
@@ -0,0 +1,104 @@
+
+# Fetch: Download progress
+
+The `fetch` method allows to track download 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 0000000000..5a58b209b5
--- /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 0000000000..ba7f76065e
--- /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 0000000000..a98e50a280
--- /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 0000000000..3e6f4cb425
--- /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 0000000000..5a0c8e4a54
--- /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 0000000000..8cbb2c88ac
--- /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 0000000000..6bfdc1094d
--- /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 0000000000..4d659a80ae
--- /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-Methods` 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-Methods: 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 `Access-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 to 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-Methods` 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 0000000000..ef5eb32430
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 0000000000..c9ff82d3c9
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 0000000000..7e367598cc
--- /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 0000000000..588ca0653e
--- /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 0000000000..0be23b1eb6
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 0000000000..030606b224
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 0000000000..a11a70926e
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 0000000000..1333ec3745
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 0000000000..7b0330f266
--- /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 0000000000..5a58b209b5
--- /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 0000000000..ba7f76065e
--- /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 0000000000..5e182a2ba7
--- /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 0000000000..4615a4e556
--- /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` starts 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` appeared, 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 0000000000..7e549d28fa
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 0000000000..cfbe21de05
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 0000000000..c6b3d62938
--- /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 <info:fetch-basics>.
+
+## 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-binary-arrays>),
+- `"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 peculiarity 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 occurred, 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 0000000000..7dbc3d9510
--- /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 0000000000..a387293b90
--- /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/5-network/07-xmlhttprequest/phones-async.view/index.html b/5-network/07-xmlhttprequest/phones-async.view/index.html
new file mode 100644
index 0000000000..dff72ba3dc
--- /dev/null
+++ b/5-network/07-xmlhttprequest/phones-async.view/index.html
@@ -0,0 +1,42 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+</head>
+<body>
+
+  <button onclick="loadPhones()" id="button">Load phones.json!</button>
+
+  <script>
+    function loadPhones() {
+
+      let xhr = new XMLHttpRequest();
+
+      xhr.open('GET', 'phones.json');
+
+
+      xhr.send();
+
+
+      xhr.onreadystatechange = function() {
+        if (xhr.readyState != 4) return;
+
+        button.innerHTML = 'Complete!';
+
+        if (xhr.status != 200) {
+          // handle error
+          alert(xhr.status + ': ' + xhr.statusText);
+        } else {
+          // show result
+          alert(xhr.responseText);
+        }
+
+      }
+
+      button.innerHTML = 'Loading...';
+      button.disabled = true;
+    }
+  </script>
+
+</body>
+</html>
diff --git a/7-network/1-xmlhttprequest/phones.json b/5-network/07-xmlhttprequest/phones-async.view/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-async.view/phones.json
diff --git a/5-network/07-xmlhttprequest/phones-async.view/server.js b/5-network/07-xmlhttprequest/phones-async.view/server.js
new file mode 100644
index 0000000000..d09318a007
--- /dev/null
+++ b/5-network/07-xmlhttprequest/phones-async.view/server.js
@@ -0,0 +1,30 @@
+var http = require('http');
+var url = require('url');
+var querystring = require('querystring');
+var static = require('node-static');
+var file = new static.Server('.', {
+  cache: 0
+});
+
+
+function accept(req, res) {
+
+  if (req.url == '/phones.json') {
+    // искусственная задержка для наглядности
+    setTimeout(function() {
+      file.serve(req, res);
+    }, 2000);
+  } else {
+    file.serve(req, res);
+  }
+
+}
+
+
+// ------ запустить сервер -------
+
+if (!module.parent) {
+  http.createServer(accept).listen(8080);
+} else {
+  exports.accept = accept;
+}
\ No newline at end of file
diff --git a/5-network/07-xmlhttprequest/phones.json b/5-network/07-xmlhttprequest/phones.json
new file mode 100644
index 0000000000..a224f59e52
--- /dev/null
+++ b/5-network/07-xmlhttprequest/phones.json
@@ -0,0 +1,155 @@
+[
+    {
+        "age": 0,
+        "id": "motorola-xoom-with-wi-fi",
+        "imageUrl": "img/phones/motorola-xoom-with-wi-fi.0.jpg",
+        "name": "Motorola XOOM\u2122 with Wi-Fi",
+        "snippet": "The Next, Next Generation\r\n\r\nExperience the future with Motorola XOOM with Wi-Fi, the world's first tablet powered by Android 3.0 (Honeycomb)."
+    },
+    {
+        "age": 1,
+        "id": "motorola-xoom",
+        "imageUrl": "img/phones/motorola-xoom.0.jpg",
+        "name": "MOTOROLA XOOM\u2122",
+        "snippet": "The Next, Next Generation\n\nExperience the future with MOTOROLA XOOM, the world's first tablet powered by Android 3.0 (Honeycomb)."
+    },
+    {
+        "age": 2,
+        "carrier": "AT&amp;T",
+        "id": "motorola-atrix-4g",
+        "imageUrl": "img/phones/motorola-atrix-4g.0.jpg",
+        "name": "MOTOROLA ATRIX\u2122 4G",
+        "snippet": "MOTOROLA ATRIX 4G the world's most powerful smartphone."
+    },
+    {
+        "age": 3,
+        "id": "dell-streak-7",
+        "imageUrl": "img/phones/dell-streak-7.0.jpg",
+        "name": "Dell Streak 7",
+        "snippet": "Introducing Dell\u2122 Streak 7. Share photos, videos and movies together. It\u2019s small enough to carry around, big enough to gather around."
+    },
+    {
+        "age": 4,
+        "carrier": "Cellular South",
+        "id": "samsung-gem",
+        "imageUrl": "img/phones/samsung-gem.0.jpg",
+        "name": "Samsung Gem\u2122",
+        "snippet": "The Samsung Gem\u2122 brings you everything that you would expect and more from a touch display smart phone \u2013 more apps, more features and a more affordable price."
+    },
+    {
+        "age": 5,
+        "carrier": "Dell",
+        "id": "dell-venue",
+        "imageUrl": "img/phones/dell-venue.0.jpg",
+        "name": "Dell Venue",
+        "snippet": "The Dell Venue; Your Personal Express Lane to Everything"
+    },
+    {
+        "age": 6,
+        "carrier": "Best Buy",
+        "id": "nexus-s",
+        "imageUrl": "img/phones/nexus-s.0.jpg",
+        "name": "Nexus S",
+        "snippet": "Fast just got faster with Nexus S. A pure Google experience, Nexus S is the first phone to run Gingerbread (Android 2.3), the fastest version of Android yet."
+    },
+    {
+        "age": 7,
+        "carrier": "Cellular South",
+        "id": "lg-axis",
+        "imageUrl": "img/phones/lg-axis.0.jpg",
+        "name": "LG Axis",
+        "snippet": "Android Powered, Google Maps Navigation, 5 Customizable Home Screens"
+    },
+    {
+        "age": 8,
+        "id": "samsung-galaxy-tab",
+        "imageUrl": "img/phones/samsung-galaxy-tab.0.jpg",
+        "name": "Samsung Galaxy Tab\u2122",
+        "snippet": "Feel Free to Tab\u2122. The Samsung Galaxy Tab\u2122 brings you an ultra-mobile entertainment experience through its 7\u201d display, high-power processor and Adobe\u00ae Flash\u00ae Player compatibility."
+    },
+    {
+        "age": 9,
+        "carrier": "Cellular South",
+        "id": "samsung-showcase-a-galaxy-s-phone",
+        "imageUrl": "img/phones/samsung-showcase-a-galaxy-s-phone.0.jpg",
+        "name": "Samsung Showcase\u2122 a Galaxy S\u2122 phone",
+        "snippet": "The Samsung Showcase\u2122 delivers a cinema quality experience like you\u2019ve never seen before. Its innovative 4\u201d touch display technology provides rich picture brilliance, even outdoors"
+    },
+    {
+        "age": 10,
+        "carrier": "Verizon",
+        "id": "droid-2-global-by-motorola",
+        "imageUrl": "img/phones/droid-2-global-by-motorola.0.jpg",
+        "name": "DROID\u2122 2 Global by Motorola",
+        "snippet": "The first smartphone with a 1.2 GHz processor and global capabilities."
+    },
+    {
+        "age": 11,
+        "carrier": "Verizon",
+        "id": "droid-pro-by-motorola",
+        "imageUrl": "img/phones/droid-pro-by-motorola.0.jpg",
+        "name": "DROID\u2122 Pro by Motorola",
+        "snippet": "The next generation of DOES."
+    },
+    {
+        "age": 12,
+        "carrier": "AT&amp;T",
+        "id": "motorola-bravo-with-motoblur",
+        "imageUrl": "img/phones/motorola-bravo-with-motoblur.0.jpg",
+        "name": "MOTOROLA BRAVO\u2122 with MOTOBLUR\u2122",
+        "snippet": "An experience to cheer about."
+    },
+    {
+        "age": 13,
+        "carrier": "T-Mobile",
+        "id": "motorola-defy-with-motoblur",
+        "imageUrl": "img/phones/motorola-defy-with-motoblur.0.jpg",
+        "name": "Motorola DEFY\u2122 with MOTOBLUR\u2122",
+        "snippet": "Are you ready for everything life throws your way?"
+    },
+    {
+        "age": 14,
+        "carrier": "T-Mobile",
+        "id": "t-mobile-mytouch-4g",
+        "imageUrl": "img/phones/t-mobile-mytouch-4g.0.jpg",
+        "name": "T-Mobile myTouch 4G",
+        "snippet": "The T-Mobile myTouch 4G is a premium smartphone designed to deliver blazing fast 4G speeds so that you can video chat from practically anywhere, with or without Wi-Fi."
+    },
+    {
+        "age": 15,
+        "carrier": "US Cellular",
+        "id": "samsung-mesmerize-a-galaxy-s-phone",
+        "imageUrl": "img/phones/samsung-mesmerize-a-galaxy-s-phone.0.jpg",
+        "name": "Samsung Mesmerize\u2122 a Galaxy S\u2122 phone",
+        "snippet": "The Samsung Mesmerize\u2122 delivers a cinema quality experience like you\u2019ve never seen before. Its innovative 4\u201d touch display technology provides rich picture brilliance,even outdoors"
+    },
+    {
+        "age": 16,
+        "carrier": "Sprint",
+        "id": "sanyo-zio",
+        "imageUrl": "img/phones/sanyo-zio.0.jpg",
+        "name": "SANYO ZIO",
+        "snippet": "The Sanyo Zio by Kyocera is an Android smartphone with a combination of ultra-sleek styling, strong performance and unprecedented value."
+    },
+    {
+        "age": 17,
+        "id": "samsung-transform",
+        "imageUrl": "img/phones/samsung-transform.0.jpg",
+        "name": "Samsung Transform\u2122",
+        "snippet": "The Samsung Transform\u2122 brings you a fun way to customize your Android powered touch screen phone to just the way you like it through your favorite themed \u201cSprint ID Service Pack\u201d."
+    },
+    {
+        "age": 18,
+        "id": "t-mobile-g2",
+        "imageUrl": "img/phones/t-mobile-g2.0.jpg",
+        "name": "T-Mobile G2",
+        "snippet": "The T-Mobile G2 with Google is the first smartphone built for 4G speeds on T-Mobile's new network. Get the information you need, faster than you ever thought possible."
+    },
+    {
+        "age": 19,
+        "id": "motorola-charm-with-motoblur",
+        "imageUrl": "img/phones/motorola-charm-with-motoblur.0.jpg",
+        "name": "Motorola CHARM\u2122 with MOTOBLUR\u2122",
+        "snippet": "Motorola CHARM fits easily in your pocket or palm.  Includes MOTOBLUR service."
+    }
+]
diff --git a/5-network/07-xmlhttprequest/phones.view/index.html b/5-network/07-xmlhttprequest/phones.view/index.html
new file mode 100644
index 0000000000..02e1fb9674
--- /dev/null
+++ b/5-network/07-xmlhttprequest/phones.view/index.html
@@ -0,0 +1,28 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+</head>
+<body>
+
+  <button onclick="loadPhones()">Load phones.json!</button>
+
+  <script>
+    function loadPhones() {
+      let xhr = new XMLHttpRequest();
+
+      xhr.open('GET', 'phones.json', false);
+      xhr.send();
+
+      if (xhr.status != 200) {
+        // handle error
+        alert('Error ' + xhr.status + ': ' + xhr.statusText);
+      } else {
+        // show result
+        alert(xhr.responseText);
+      }
+    }
+  </script>
+
+</body>
+</html>
diff --git a/5-network/07-xmlhttprequest/phones.view/phones.json b/5-network/07-xmlhttprequest/phones.view/phones.json
new file mode 100644
index 0000000000..472b2b169f
--- /dev/null
+++ b/5-network/07-xmlhttprequest/phones.view/phones.json
@@ -0,0 +1,155 @@
+[
+    {
+        "age": 0, 
+        "id": "motorola-xoom-with-wi-fi", 
+        "imageUrl": "img/phones/motorola-xoom-with-wi-fi.0.jpg", 
+        "name": "Motorola XOOM\u2122 with Wi-Fi", 
+        "snippet": "The Next, Next Generation\r\n\r\nExperience the future with Motorola XOOM with Wi-Fi, the world's first tablet powered by Android 3.0 (Honeycomb)."
+    }, 
+    {
+        "age": 1, 
+        "id": "motorola-xoom", 
+        "imageUrl": "img/phones/motorola-xoom.0.jpg", 
+        "name": "MOTOROLA XOOM\u2122", 
+        "snippet": "The Next, Next Generation\n\nExperience the future with MOTOROLA XOOM, the world's first tablet powered by Android 3.0 (Honeycomb)."
+    }, 
+    {
+        "age": 2, 
+        "carrier": "AT&amp;T", 
+        "id": "motorola-atrix-4g", 
+        "imageUrl": "img/phones/motorola-atrix-4g.0.jpg", 
+        "name": "MOTOROLA ATRIX\u2122 4G", 
+        "snippet": "MOTOROLA ATRIX 4G the world's most powerful smartphone."
+    }, 
+    {
+        "age": 3, 
+        "id": "dell-streak-7", 
+        "imageUrl": "img/phones/dell-streak-7.0.jpg", 
+        "name": "Dell Streak 7", 
+        "snippet": "Introducing Dell\u2122 Streak 7. Share photos, videos and movies together. It\u2019s small enough to carry around, big enough to gather around."
+    }, 
+    {
+        "age": 4, 
+        "carrier": "Cellular South", 
+        "id": "samsung-gem", 
+        "imageUrl": "img/phones/samsung-gem.0.jpg", 
+        "name": "Samsung Gem\u2122", 
+        "snippet": "The Samsung Gem\u2122 brings you everything that you would expect and more from a touch display smart phone \u2013 more apps, more features and a more affordable price."
+    }, 
+    {
+        "age": 5, 
+        "carrier": "Dell", 
+        "id": "dell-venue", 
+        "imageUrl": "img/phones/dell-venue.0.jpg", 
+        "name": "Dell Venue", 
+        "snippet": "The Dell Venue; Your Personal Express Lane to Everything"
+    }, 
+    {
+        "age": 6, 
+        "carrier": "Best Buy", 
+        "id": "nexus-s", 
+        "imageUrl": "img/phones/nexus-s.0.jpg", 
+        "name": "Nexus S", 
+        "snippet": "Fast just got faster with Nexus S. A pure Google experience, Nexus S is the first phone to run Gingerbread (Android 2.3), the fastest version of Android yet."
+    }, 
+    {
+        "age": 7, 
+        "carrier": "Cellular South", 
+        "id": "lg-axis", 
+        "imageUrl": "img/phones/lg-axis.0.jpg", 
+        "name": "LG Axis", 
+        "snippet": "Android Powered, Google Maps Navigation, 5 Customizable Home Screens"
+    }, 
+    {
+        "age": 8, 
+        "id": "samsung-galaxy-tab", 
+        "imageUrl": "img/phones/samsung-galaxy-tab.0.jpg", 
+        "name": "Samsung Galaxy Tab\u2122", 
+        "snippet": "Feel Free to Tab\u2122. The Samsung Galaxy Tab\u2122 brings you an ultra-mobile entertainment experience through its 7\u201d display, high-power processor and Adobe\u00ae Flash\u00ae Player compatibility."
+    }, 
+    {
+        "age": 9, 
+        "carrier": "Cellular South", 
+        "id": "samsung-showcase-a-galaxy-s-phone", 
+        "imageUrl": "img/phones/samsung-showcase-a-galaxy-s-phone.0.jpg", 
+        "name": "Samsung Showcase\u2122 a Galaxy S\u2122 phone", 
+        "snippet": "The Samsung Showcase\u2122 delivers a cinema quality experience like you\u2019ve never seen before. Its innovative 4\u201d touch display technology provides rich picture brilliance, even outdoors"
+    }, 
+    {
+        "age": 10, 
+        "carrier": "Verizon", 
+        "id": "droid-2-global-by-motorola", 
+        "imageUrl": "img/phones/droid-2-global-by-motorola.0.jpg", 
+        "name": "DROID\u2122 2 Global by Motorola", 
+        "snippet": "The first smartphone with a 1.2 GHz processor and global capabilities."
+    }, 
+    {
+        "age": 11, 
+        "carrier": "Verizon", 
+        "id": "droid-pro-by-motorola", 
+        "imageUrl": "img/phones/droid-pro-by-motorola.0.jpg", 
+        "name": "DROID\u2122 Pro by Motorola", 
+        "snippet": "The next generation of DOES."
+    }, 
+    {
+        "age": 12, 
+        "carrier": "AT&amp;T", 
+        "id": "motorola-bravo-with-motoblur", 
+        "imageUrl": "img/phones/motorola-bravo-with-motoblur.0.jpg", 
+        "name": "MOTOROLA BRAVO\u2122 with MOTOBLUR\u2122", 
+        "snippet": "An experience to cheer about."
+    }, 
+    {
+        "age": 13, 
+        "carrier": "T-Mobile", 
+        "id": "motorola-defy-with-motoblur", 
+        "imageUrl": "img/phones/motorola-defy-with-motoblur.0.jpg", 
+        "name": "Motorola DEFY\u2122 with MOTOBLUR\u2122", 
+        "snippet": "Are you ready for everything life throws your way?"
+    }, 
+    {
+        "age": 14, 
+        "carrier": "T-Mobile", 
+        "id": "t-mobile-mytouch-4g", 
+        "imageUrl": "img/phones/t-mobile-mytouch-4g.0.jpg", 
+        "name": "T-Mobile myTouch 4G", 
+        "snippet": "The T-Mobile myTouch 4G is a premium smartphone designed to deliver blazing fast 4G speeds so that you can video chat from practically anywhere, with or without Wi-Fi."
+    }, 
+    {
+        "age": 15, 
+        "carrier": "US Cellular", 
+        "id": "samsung-mesmerize-a-galaxy-s-phone", 
+        "imageUrl": "img/phones/samsung-mesmerize-a-galaxy-s-phone.0.jpg", 
+        "name": "Samsung Mesmerize\u2122 a Galaxy S\u2122 phone", 
+        "snippet": "The Samsung Mesmerize\u2122 delivers a cinema quality experience like you\u2019ve never seen before. Its innovative 4\u201d touch display technology provides rich picture brilliance,even outdoors"
+    }, 
+    {
+        "age": 16, 
+        "carrier": "Sprint", 
+        "id": "sanyo-zio", 
+        "imageUrl": "img/phones/sanyo-zio.0.jpg", 
+        "name": "SANYO ZIO", 
+        "snippet": "The Sanyo Zio by Kyocera is an Android smartphone with a combination of ultra-sleek styling, strong performance and unprecedented value."
+    }, 
+    {
+        "age": 17, 
+        "id": "samsung-transform", 
+        "imageUrl": "img/phones/samsung-transform.0.jpg", 
+        "name": "Samsung Transform\u2122", 
+        "snippet": "The Samsung Transform\u2122 brings you a fun way to customize your Android powered touch screen phone to just the way you like it through your favorite themed \u201cSprint ID Service Pack\u201d."
+    }, 
+    {
+        "age": 18, 
+        "id": "t-mobile-g2", 
+        "imageUrl": "img/phones/t-mobile-g2.0.jpg", 
+        "name": "T-Mobile G2", 
+        "snippet": "The T-Mobile G2 with Google is the first smartphone built for 4G speeds on T-Mobile's new network. Get the information you need, faster than you ever thought possible."
+    }, 
+    {
+        "age": 19, 
+        "id": "motorola-charm-with-motoblur", 
+        "imageUrl": "img/phones/motorola-charm-with-motoblur.0.jpg", 
+        "name": "Motorola CHARM\u2122 with MOTOBLUR\u2122", 
+        "snippet": "Motorola CHARM fits easily in your pocket or palm.  Includes MOTOBLUR service."
+    }
+]
diff --git a/5-network/07-xmlhttprequest/phones.view/server.js b/5-network/07-xmlhttprequest/phones.view/server.js
new file mode 100644
index 0000000000..d8bf907853
--- /dev/null
+++ b/5-network/07-xmlhttprequest/phones.view/server.js
@@ -0,0 +1,30 @@
+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.url == '/phones.json') {
+    // stall a bit to let "loading" message show up
+    setTimeout(function() {
+      file.serve(req, res);
+    }, 2000);
+  } else {
+    file.serve(req, res);
+  }
+
+}
+
+
+// ------ запустить сервер -------
+
+if (!module.parent) {
+  http.createServer(accept).listen(8080);
+} else {
+  exports.accept = accept;
+}
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 0000000000..ba7f76065e
--- /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 0000000000..50cfc5ae36
--- /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 0000000000..a7773874f2
--- /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` 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 protocols 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, any 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 beyond 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 persistent 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 that 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 0000000000..3dd4c24cd9
--- /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 0000000000..d21973fc75
--- /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 0000000000..7b17734d7c
--- /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 0000000000..74ca42520d
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 0000000000..34a2610271
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 0000000000..31f86f0925
--- /dev/null
+++ b/5-network/index.md
@@ -0,0 +1,2 @@
+
+# Network requests
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 ba293e6dae..0000000000
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 9ebf623b3a..0000000000
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 b8ed77c0f5..0000000000
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 9fb998b98b..0000000000
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/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 5db6f17a82..0000000000
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 966e27aa85..0000000000
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 9fdbe2343d..0000000000
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 91e6658246..0000000000
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 aeef75bd6b..0000000000
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 a8c62e60d7..0000000000
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 c18ab43ecb..0000000000
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 823a371710..0000000000
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 12442d2bdc..0000000000
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 29d3cf0af7..0000000000
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 3ed72b25dc..0000000000
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 4833e67699..0000000000
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 1e0ce4178f..0000000000
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 1e378468dc..0000000000
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 478834eec1..0000000000
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 495a2f2430..0000000000
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 e50543675b..0000000000
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 870d463305..0000000000
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 66728501c4..0000000000
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 4228e193b5..0000000000
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/15-regexp-infinite-backtracking-problem/article.md b/5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
deleted file mode 100644
index 1e423578f0..0000000000
--- a/5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+++ /dev/null
@@ -1,272 +0,0 @@
-# 无限回溯问题
-
-有些正则表达式看起来简单，但会执行很长很长的时间，甚至会“挂起” JavaScript 引擎。
-
-绝大多数开发者迟早会遇到这种行为。
-
-典型的情况 —— 一个正则表达式有时候工作正常，但对于特定的字符串它会“挂起”占用 100% 的 CPU。
-
-这甚至可能是一个漏洞。例如，如果 JavaScript 运行在服务器上，并且它使用正则表达式来处理用户数据，那么这样的输入可能会拒绝服务。笔者亲自看到并报告过这些漏洞，即使对于众所周知且广泛使用的程序也是如此。
-
-所以这个问题是绝对值得解决的。
-
-## 实例
-
-计划将会是这样的：
-
-1. 首先我们观察问题是如何出现的。
-2. 然后我们简化场景并分析问题为什么会出现。
-3. 然后我们修复它。
-
-例如，让我们考虑在 HTML 中查找标签。
-
-我们想要查找所有的标签，有或者没有属性 —— 比如 `<a href="..." class="doc" ...>`。我们需要正则表达式可靠地工作，因为 HMTL 是来自网络的并可能会很混乱。
-
-特别的，我们需要匹配像 `<a test="<>" href="#">` —— 属性里有 `<` 和 `>` 的标签。这在 [HTML standard](https://html.spec.whatwg.org/multipage/syntax.html#syntax-attributes) 中是允许的。
-
-现在我们可以看到像 `<[^>]+>` 这样简单的正则表达式不起作用，因为它停在了第一个 `>`，我们需要忽略属性里的 `<>`。
-
-```js run
-// 匹配没有抵达标签的末尾 —— 错误！
-alert( '<a test="<>" href="#">'.match(/<[^>]+>/) ); // <a test="<>
-```
-
-我们需要整个标签。
-
-要正确处理这种情况我们需要一个更复杂的正则表达式。它将有 `<tag (key=value)*>` 这样的形式。
-
-在正则表达式语言中是 `<\w+(\s*\w+=(\w+|"[^"]*")\s*)*>`：
-
-1. `<\w+` —— 是标签的开始,
-2. `(\s*\w+=(\w+|"[^"]*")\s*)*` —— 是一个任意数量的 `word=value` 对，其中值可以是单词 `\w+` 或者一个带引号的字符串 `"[^"]*"`。
-
-这还不支持 HTML 语法的一些细节，例如在“单个”引号中的字符串，但它们可以以后添加，因此它们和现实生活有些接近。目前我们想要简单的正则表达式。
-
-让我们实际操作一下：
-
-```js run
-let reg = /<\w+(\s*\w+=(\w+|"[^"]*")\s*)*>/g;
-
-let str='...<a test="<>" href="#">... <b>...';
-
-alert( str.match(reg) ); // <a test="<>" href="#">, <b>
-```
-
-很好，它生效了。它找到了长标签 `<a test="<>" href="#">` 和短标签 `<b>`。
-
-现在让我们看看问题。
-
-如果你运行下面的示例，它可能会挂起浏览器（或任何运行的 JavaScript 引擎）：
-
-```js run
-let reg = /<\w+(\s*\w+=(\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`;
-
-*!*
-// 查询会耗费很长很长的时间
-alert( str.match(reg) );
-*/!*
-```
-
-一些正则表达式引擎可以处理该搜索，但大多数都不行。
-
-这是怎么回事？为什么在这么小的字符串上，一个简单的正则表达式会“挂起” ？
-
-让我们通过删除标记和引用的字符串来简化场景。
-
-这里我们只查看属性：
-
-```js run
-// 只查找用空格分隔的属性
-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`;
-
-*!*
-// 查询会耗费很长很长的时间
-alert( str.match(reg) );
-*/!*
-```
-
-同样的问题仍然存在。
-
-在这里，我们结束问题的演示，并开始研究发生了什么以及它为什么会挂起。
-
-## 回溯
-
-为了使问题更简单，我们考虑一下 `(\d+)*$`。
-
-这个正则表达式也有同样的问题。在大多数正则表达式引擎中，搜索需要很长时间（小心 —— 会挂起）：
-
-```js run
-alert( '12345678901234567890123456789123456789z'.match(/(\d+)*$/) );
-```
-
-那么这个正则表达式有什么问题？
-
-首先，有人可能注意到这个正则表达式有一点奇怪。量词 `*` 看起来是多余的。如果我们需要一个数字，我们可以使用 `\d+$`。
-
-实际上，正则表达式是人写的。但它缓慢的原因与我们上面看到的相同。所以让我们理解它，然后回到现实生活中的例子。
-
-在线路 `123456789z` 中搜索 `(\d+)*$` 期间发生了什么？
-
-1. 首先，regexp 引擎试图找到一个数字 `\d+`。默认情况下，加号 `+` 是贪婪的，所以它消耗所有数字：
-
-    ```
-    \d+.......
-    (123456789)z
-    ```
-2. 然后它试图在括号周围应用星号 `(\d+)*`，但没有更多的数字，所以星号没有给出任何东西。
-
-    然后该模式具有字符串结束锚 `$`，并且在文本中我们有 `z`。
-
-    ```
-               X
-    \d+........$
-    (123456789)z
-    ```
-
-    没有匹配！
-3. 没有匹配，所以贪婪的量词 `+` 会减少重复次数（回溯）。
-
-    现在 `\d+` 就不是所有数字了，而是除最后一个之外的所有数字：
-    ```
-    \d+.......
-    (12345678)9z
-    ```
-4. 现在引擎尝试从新位置（`9`）继续搜索。
-
-    起始的 `(\d+)*` 可以被应用上 —— 它给出了数字 `9`：
-
-    ```
-
-    \d+.......\d+
-    (12345678)(9)z
-    ```
-
-    引擎再次尝试匹配 `$`，但失败了，因为遇到 `z`：
-
-    ```
-                 X
-    \d+.......\d+
-    (12345678)(9)z
-    ```
-
-    没有匹配，因此引擎将继续回溯。
-5. 现在第一个数字 `\d+` 将会有 7 位数，字符串的其余部分 `89` 是第二个数字 `\d+`：
-
-    ```
-                 X
-    \d+......\d+
-    (1234567)(89)z
-    ```
-
-    ...仍然无法匹配 `$`。
-
-    搜索引擎会再次回溯。回溯通常是这样工作的：只要可以最后一个贪心量词会减少重复次数。然后先前的贪心量词减少，依此类推。在我们的例子中，最后一个贪心量词是第二个 `\d+`，从 `89` 变为 `8`，星号匹配到 `9`：
-	
-    ```
-                   X
-    \d+......\d+\d+
-    (1234567)(8)(9)z
-    ```
-6. ...再次失败。第二个和第三个 `\d+` 回溯到最后，所以第一个量词缩短为匹配 `123456`，然后星号匹配剩余部分：
-
-    ```
-                 X
-    \d+.......\d+
-    (123456)(789)z
-    ```
-
-    再次失败。重复该过程：最后一个贪心量词释放一个字符（`9`）：
-
-    ```
-                   X
-    \d+.....\d+ \d+
-    (123456)(78)(9)z
-    ```
-7. ...然后继续。
-
-正则表达式引擎遍历了 `123456789` 子序列的所有组合。它们是有很多的，这就是为什么它会花费这么长时间。
-
-一个聪明的家伙可能在这里会说：“回溯？让我们打开懒惰模式 —— 不再有回溯！”。
-
-让我们用 `\d+?` 代替 `\d+`，看它是否生效（小心，会引起浏览器挂起）
-
-```js run
-// 非非非常慢
-alert( '12345678901234567890123456789123456789z'.match(/(\d+?)*$/) );
-```
-
-不，它没有（生效）。
-
-惰性量词实际上是一样的，只是顺序相反。试想一下搜索引擎在这种情况下会怎么工作。
-
-有些正则表达式引擎具有复杂的内置检查来检测无限回溯或其他方法来解决它们，但是没有通用的解决方案。
-
-在上面的例子中，当我们在字符串 `<a=b  a=b  a=b  a=b` 中查找 `<(\s*\w+=\w+\s*)*>` 时 —— 类似的情况发生了。
-
-字符串最后没有包含 `>`，所以匹配是不可能的，但正则表达式引擎不知道这些。搜索回溯尝试 `(\s*\w+=\w+\s*)` 的不同组合：
-
-```
-(a=b a=b a=b) (a=b)
-(a=b a=b) (a=b a=b)
-...
-```
-
-## 如何修复？
-
-问题 —— 即便我们不需要它们，回溯也有很多变种。
-
-例如，在模式 `(\d+)*$` 中，我们（人类）可以轻易的看到 `(\d+)` 不需要回溯。
-
-减少 `\d+` 的计数对匹配没有帮助，这两者没有区别：
-
-```
-\d+........
-(123456789)z
-
-\d+...\d+....
-(1234)(56789)z
-```
-
-让我们回到更现实生活中的例子：`<(\s*\w+=\w+\s*)*>`。我们想要查找键值对 `name=value`（尽可能多）。这里没有必要回溯。
-
-换而言之，如果它找到很多 `name=value` 对然后找不到 `>`，那就没有必要减少重复次数。即使我们少匹配一对，它也不会给我们闭合的 `>`：
-
-现代的正则表达式引擎支持所谓的“占有”量词。它们就像贪婪，但根本不回溯。很简单的，它们抓取尽可能多的东西，然后继续搜索。还有另一种叫做“原子组”的工具用来禁止括号内部的回溯。
-
-不幸的是，JavaScript 对这两项功能都不支持。
-
-虽然我们可以使用前瞻来获得类似的效果。在文章[正则表达式: 使用前瞻模拟原子分组（和占有量词）](http://instanceof.me/post/52245507631/regex-emulate-atomic-grouping-with-lookahead)和[模拟原子组](http://blog.stevenlevithan.com/archives/mimic-atomic-groups)中更多关于占有量词和前瞻之间的关系。
-
-在没有回溯的前提下尽可能多重复使用的模式是：`(?=(a+))\1`。
-
-换句话说，前瞻 `?=` 从当前位置查找最大 `a+` 的计数。然后他们被 `\1` 反向引用“消耗在结果中”。
-
-这里没有回溯，因为前瞻不会回溯。如果它检索了 5 次 `a+` 并且进一步匹配失败，那么它不会回到 4。
-
-让我们修复本章开头的带有属性标签的正则表达式 `<\w+(\s*\w+=(\w+|"[^"]*")\s*)*>`。我们将使用前瞻来防止 `name=value` 对的回溯：
-
-```js run
-// 搜索 name=value 的正则表达式
-let attrReg = /(\s*\w+=(\w+|"[^"]*")\s*)/
-
-// 在标签正则表达式中使用
-let reg = new RegExp('<\\w+(?=(' + attrReg.source + '*))\\1>', 'g');
-
-let good = '...<a test="<>" href="#">... <b>...';
-
-let bad = `<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!)
-```
-
-很好，它起作用了。我们找到一个长标签 `<a test="<>" href="#">` 和一个小标签 `<b>`，并且没有挂起引擎。
-
-请留意 `attrReg.source` 属性。`RegExp` 对象提供对其源字符串的访问。当我们想要将一个正则表达式插入另一个正则表达式时，这很方便。
diff --git a/6-async/01-callbacks/callback-hell.png b/6-async/01-callbacks/callback-hell.png
deleted file mode 100644
index f42224a268..0000000000
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 7c9a3ab5ed..0000000000
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 38f27c735a..0000000000
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 f9b748ff0a..0000000000
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 0dfe7bada2..0000000000
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 269b8f2908..0000000000
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 505726efd5..0000000000
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 31128dbe09..0000000000
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/02-error-async/task.md b/6-async/03-promise-chaining/02-error-async/task.md
deleted file mode 100644
index 74142c41eb..0000000000
--- a/6-async/03-promise-chaining/02-error-async/task.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# setTimeout 中的错误
-
-你认为 `.catch` 会不会触发？请解释一下？
-
-```js
-new Promise(function(resolve, reject) {
-  setTimeout(() => {
-    throw new Error("Whoops!");
-  }, 1000);
-}).catch(alert);
-```
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 1b4eff7afe..0000000000
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 241733fb69..0000000000
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 541c18eb29..0000000000
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 3a2f6b1d8b..0000000000
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 7cd1baa93c..0000000000
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 3d981342bd..0000000000
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 199867f841..0000000000
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 2e7847eb2a..0000000000
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 0000000000..fcb7c78d5f
--- /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 of safe 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 0000000000..7e8b13fd88
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 0000000000..461f688718
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 0000000000..fa10aa2a76
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 0000000000..d7a583469c
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 0000000000..907217c064
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 0000000000..c2d98ae61b
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 0000000000..92447bb17c
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 0000000000..d20e5fdde9
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 0000000000..7d8eebf3e6
--- /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 0000000000..1a4fb86859
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 0000000000..6c3f9d824c
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 0000000000..8b13789179
--- /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 0000000000..7be1989270
--- /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 0000000000..95a741758d
--- /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 0000000000..b2e0a42228
--- /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 0000000000..16be552aef
--- /dev/null
+++ b/6-data-storage/02-localstorage/article.md
@@ -0,0 +1,249 @@
+# 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.
+- Also unlike cookies, 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.
+
+As you can see, it's like a `Map` collection (`setItem/getItem/removeItem`), but also keeps elements order and allows to access by index with `key(index)`.
+
+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
+
+As we've seen, the methods provide get/set/remove functionality. But how to get all saved values or keys?
+
+Unfortunately, storage objects are not iterable.
+
+One way is to loop over them as over an array:
+
+```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 `for key in localStorage` loop, just as we do with regular objects.
+
+It 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 were 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 even 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 isn't triggered.
+
+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 0000000000..2555160b57
--- /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 0000000000..110143e586
--- /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 0000000000..d7fc5bbbde
--- /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 0000000000..11c12da7b9
--- /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 0000000000..7c53219c99
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 0000000000..f4392edfed
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 0000000000..4fdc18976d
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 0000000000..4068903046
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 0000000000..642e4d742e
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 0000000000..2e4f389fd9
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 0000000000..a08c05b580
--- /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 56%
rename from 3-animation/1-bezier-curve/article.md
rename to 7-animation/1-bezier-curve/article.md
index 63a0335cc8..e91ab820ab 100644
--- a/3-animation/1-bezier-curve/article.md
+++ b/7-animation/1-bezier-curve/article.md
@@ -2,7 +2,11 @@
 
 贝塞尔曲线用于计算机图形绘制形状，CSS 动画和许多其他地方。
 
+<<<<<<< HEAD:3-animation/1-bezier-curve/article.md
 他们其实非常简单，值得学习一次并且在矢量图形和高级动画的世界里非常受用。
+=======
+They are a very simple thing, worth to study once and then feel comfortable in the world of vector graphics and advanced animations.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/1-bezier-curve/article.md
 
 ## 控制点
 
@@ -33,7 +37,11 @@
 
 由于最后一个属性，在计算机图形学中，可以优化相交测试。如果凸包不相交，则曲线也不相交。因此，首先检查凸包的交叉点可以非常快地给出“无交叉”结果。检查交叉区域或凸包更容易，因为它们是矩形，三角形等（见上图），比曲线简单的多。
 
+<<<<<<< HEAD:3-animation/1-bezier-curve/article.md
 贝塞尔曲线绘制的主要重点 —— 通过移动曲线，曲线**以直观明显的**方式变化。
+=======
+**The main value of Bezier curves for drawing -- by moving the points the curve is changing *in intuitively obvious way*.**
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/1-bezier-curve/article.md
 
 尝试在下面的示例中使用鼠标移动控制点：
 
@@ -47,6 +55,7 @@
 
 ![](bezier-car.png) ![](bezier-letter.png) ![](bezier-vase.png)
 
+<<<<<<< HEAD:3-animation/1-bezier-curve/article.md
 ## 数学
 
 贝塞尔曲线可以使用数学方程式来描述。
@@ -90,10 +99,22 @@
 [德卡斯特里奥算法](https://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm)与曲线的数学定义相同，但直观地显示了曲线是如何被建立的。
 
 让我们看看 3 个控制点的例子。
+=======
+## De Casteljau's algorithm
+
+There's a mathematical formula for Bezier curves, but let's cover it a bit later, because
+[De Casteljau's algorithm](https://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm) it is identical to the mathematical definition and visually shows how it is constructed.
+
+First let's see the 3-points example.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/1-bezier-curve/article.md
 
 这里是一个演示，随后会有解释。
 
+<<<<<<< HEAD:3-animation/1-bezier-curve/article.md
 控制点可以用鼠标移动，点击 “play” 运行演示。
+=======
+Control points (1,2 and 3) can be moved by the mouse. Press the "play" button to run it.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/1-bezier-curve/article.md
 
 [iframe src="demo.svg?p=0,0,0.5,1,1,0&animate=1" height=370]
 
@@ -116,12 +137,17 @@
 | ------------------------ | ---------------------- |
 | ![](bezier3-draw1.png)   | ![](bezier3-draw2.png) |
 
+<<<<<<< HEAD:3-animation/1-bezier-curve/article.md
 4. 现在在<span style="color:#167490">蓝色</span>线段上取一个点，距离比例取相同数值的 `t`。也就是说，当 `t=0.25`（左图）时，我们取到的点位于线段的左 1/4 终点处，当 `t=0.5`（右图）时 — 线段中间。在上图中这一点是<span style="color:red">红色</span>的。
+=======
+4. Now in the <span style="color:#167490">blue</span> segment take a point on the distance proportional to the same value of `t`. That is, for `t=0.25` (the left picture) we have a point at the end of the left quarter of the segment, and for `t=0.5` (the right picture) -- in the middle of the segment. On pictures above that point is <span style="color:red">red</span>.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/1-bezier-curve/article.md
 
 5. 随着 `t` 从 `0` to `1` 变化，每一个 `t` 的值都会添加一个点到曲线上。这些点的集合就形成的贝塞尔曲线。它在上面的图中是红色的，并且是抛物线状的。
 
 这是三控制点的处理过程，但是对于 4 个点同样适用。
 
+<<<<<<< HEAD:3-animation/1-bezier-curve/article.md
 4 个控制点的演示（点可以被鼠标移动）：
 
 [iframe src="demo.svg?p=0,0,0.5,0,0.5,1,1,1&animate=1" height=370]
@@ -134,9 +160,24 @@
     - 在这些线段上同样按比例 `t` 取点，得到一条<span style="color:#167490">蓝色线段</span>。
     - 在蓝色线段按比例 `t` 取点。在上面的例子中是<span style="color:red">红色</span>的。
 - 这些点在一起组成了曲线。
+=======
+The demo for 4 points (points can be moved by a mouse):
+
+[iframe src="demo.svg?p=0,0,0.5,0,0.5,1,1,1&animate=1" height=370]
+
+The algorithm for 4 points:
+
+- Connect control points by segments: 1 -> 2, 2 -> 3, 3 -> 4. There will be 3 <span style="color:#825E28">brown</span> segments.
+- For each `t` in the interval from `0` to `1`:
+    - We take points on these segments on the distance proportional to `t` from the beginning. These points are connected, so that we have two <span style="color:#0A0">green segments</span>.
+    - On these segments we take points proportional to `t`. We get one <span style="color:#167490">blue segment</span>.
+    - On the blue segment we take a point proportional to `t`. On the example above it's <span style="color:red">red</span>.
+- These points together form the curve.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/1-bezier-curve/article.md
 
 该算法是递归的，并且可以适应于任意数量的控制点。
 
+<<<<<<< HEAD:3-animation/1-bezier-curve/article.md
 给定 N 个控制点，我们将它们连接起来以获得初始的 N-1 个线段。
 
 然后对从 `0` 到 `1` 的每一个 `t`：
@@ -164,27 +205,120 @@
 
 ```smart header="如何通过给定点绘制曲线？"
 我们使用控制点制作贝塞尔曲线。正如我们所见，它们并不在曲线上。或者更准确地说，第一个和最后一个在曲线上，但其它的不在。
+=======
+Given N of control points:
+
+1. We connect them to get initially N-1 segments.
+2. Then for each `t` from `0` to `1`, we take a point on each segment on the distance proportional to `t` and connect them. There will be N-2 segments.
+3. Repeat step 2 until there is only one point.
+
+These points make the curve.
+
+```online
+**Run and pause examples to clearly see the segments and how the curve is built.**
+```
+
+
+A curve that looks like `y=1/t`:
+
+[iframe src="demo.svg?p=0,0,0,0.75,0.25,1,1,1&animate=1" height=370]
+
+Zig-zag control points also work fine:
+
+[iframe src="demo.svg?p=0,0,1,0.5,0,0.5,1,1&animate=1" height=370]
+
+Making a loop is possible:
+
+[iframe src="demo.svg?p=0,0,1,0.5,0,1,0.5,0&animate=1" height=370]
+
+A non-smooth Bezier curve (yeah, that's possible too):
+
+[iframe src="demo.svg?p=0,0,1,1,0,1,1,0&animate=1" height=370]
+
+```online
+If there's something unclear in the algorithm description, please look at the live examples above to see how
+the curve is built.
+```
+
+As the algorithm is recursive, we can build Bezier curves of any order, that is: using 5, 6 or more control points. But in practice many points are less useful. Usually we take 2-3 points, and for complex lines glue several curves together. That's simpler to develop and calculate.
+
+```smart header="How to draw a curve *through* given points?"
+To specify a Bezier curve, control points are used. As we can see, they are not on the curve, except the first and the last ones.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/1-bezier-curve/article.md
 
 有时我们有另一种任务：绘制一条曲线**通过几个点**，让它们都在一条平滑曲线上。这种任务叫[插值](https://en.wikipedia.org/wiki/Interpolation)，这里我们不覆盖讲解它。
 
+<<<<<<< HEAD:3-animation/1-bezier-curve/article.md
 这些曲线有数学方程式，例如[拉格朗日多项式](https://en.wikipedia.org/wiki/Lagrange_polynomial)。
 
 在计算机图形中[样条插值](https://en.wikipedia.org/wiki/Spline_interpolation)通常用于构建连接多个点的平滑曲线。
 ```
 
 ## 总结
+=======
+There are mathematical formulas for such curves, for instance [Lagrange polynomial](https://en.wikipedia.org/wiki/Lagrange_polynomial). In computer graphics [spline interpolation](https://en.wikipedia.org/wiki/Spline_interpolation) is often used to build smooth curves that connect many points.
+```
+
+
+## Maths
+
+A Bezier curve can be described using a mathematical formula.
+
+As we saw -- there's actually no need to know it, most people just draw the curve by moving points with a mouse. But if you're into maths -- here it is.
+
+Given the coordinates of control points <code>P<sub>i</sub></code>: the first control point has coordinates <code>P<sub>1</sub> = (x<sub>1</sub>, y<sub>1</sub>)</code>, the second: <code>P<sub>2</sub> = (x<sub>2</sub>, y<sub>2</sub>)</code>, and so on, the curve coordinates are described by the equation that depends on the parameter `t` from the segment `[0,1]`.
+
+- The formula for a 2-points curve:
+
+    <code>P = (1-t)P<sub>1</sub> + tP<sub>2</sub></code>
+- For 3 control points:
+
+    <code>P = (1−t)<sup>2</sup>P<sub>1</sub> + 2(1−t)tP<sub>2</sub> + t<sup>2</sup>P<sub>3</sub></code>
+- For 4 control points:
+
+    <code>P = (1−t)<sup>3</sup>P<sub>1</sub> + 3(1−t)<sup>2</sup>tP<sub>2</sub>  +3(1−t)t<sup>2</sup>P<sub>3</sub> + t<sup>3</sup>P<sub>4</sub></code>
+
+
+These are vector equations. In other words, we can put `x` and `y` instead of `P` to get corresponding coordinates.
+
+For instance, the 3-point curve is formed by points `(x,y)` calculated as:
+
+- <code>x = (1−t)<sup>2</sup>x<sub>1</sub> + 2(1−t)tx<sub>2</sub> + t<sup>2</sup>x<sub>3</sub></code>
+- <code>y = (1−t)<sup>2</sup>y<sub>1</sub> + 2(1−t)ty<sub>2</sub> + t<sup>2</sup>y<sub>3</sub></code>
+
+Instead of <code>x<sub>1</sub>, y<sub>1</sub>, x<sub>2</sub>, y<sub>2</sub>, x<sub>3</sub>, y<sub>3</sub></code> we should put coordinates of 3 control points, and then as `t` moves from `0` to `1`, for each value of `t` we'll have `(x,y)` of the curve.
+
+For instance, if control points are  `(0,0)`, `(0.5, 1)` and `(1, 0)`, the equations become:
+
+- <code>x = (1−t)<sup>2</sup> * 0 + 2(1−t)t * 0.5 + t<sup>2</sup> * 1 = (1-t)t + t<sup>2</sup> = t</code>
+- <code>y = (1−t)<sup>2</sup> * 0 + 2(1−t)t * 1 + t<sup>2</sup> * 0 = 2(1-t)t = –t<sup>2</sup> + 2t</code>
+
+Now as `t` runs from `0` to `1`, the set of values `(x,y)` for each `t` forms the curve for such control points.
+
+## Summary
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/1-bezier-curve/article.md
 
 贝塞尔曲线由其控制点定义。
 
 贝塞尔曲线的两种定义方法：
 
+<<<<<<< HEAD:3-animation/1-bezier-curve/article.md
 1. 使用数学方程式。
 2. 使用绘图过程：德卡斯特里奥算法
+=======
+1. Using a drawing process: De Casteljau's algorithm.
+2. Using a mathematical formulas.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/1-bezier-curve/article.md
 
 贝塞尔曲线的优点：
 
+<<<<<<< HEAD:3-animation/1-bezier-curve/article.md
 - 我们可以通过控制点移动来用鼠标绘制平滑线条。
 - 复杂的形状可以由多条贝塞尔曲线组成。
+=======
+- We can draw smooth lines with a mouse by moving control points.
+- Complex shapes can be made of several Bezier curves.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb: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 0000000000..32d9596553
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 0000000000..9debd3ba9a
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 0000000000..fa9d232256
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 0000000000..e7e59ffd2c
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 0000000000..6c92f24664
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 0000000000..ccb977d7c4
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 0000000000..50df50963c
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 0000000000..66cb9a2119
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 0000000000..2f3b3f8e3c
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 0000000000..bd9ff640ce
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 0000000000..aead6cea57
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 0000000000..8d03793ea1
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 0000000000..0e9b8d3728
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 0000000000..21ad2bb127
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 0000000000..0af6c479ad
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 0000000000..1390cbaa7c
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 0000000000..4f0bcae590
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 0000000000..34e89e6323
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 0000000000..f4ebc4a3c0
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 0000000000..ddf3c2ec44
Binary files /dev/null and b/7-animation/1-bezier-curve/bezier4@2x.png differ
diff --git a/7-animation/1-bezier-curve/demo.svg b/7-animation/1-bezier-curve/demo.svg
new file mode 100644
index 0000000000..fbf8e87d5a
--- /dev/null
+++ b/7-animation/1-bezier-curve/demo.svg
@@ -0,0 +1 @@
+<?xml version="1.0" ?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/SVG/DTD/svg10.dtd">
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns:xlink="http://www.w3.org/1999/xlink" width="340" height="360">
<!--+ no-optimize -->
<!--
@see
http://www.learnsvg.com/books/learnsvg/html/bitmap/chapter04/page04-1.php
http://apike.ca/prog_svg_paths.html
http://www.the-art-of-web.com/css/css-animation/
http://srufaculty.sru.edu/david.dailey/svg/curve.svg
http://www.w3.org/Graphics/SVG/IG/resources/svgprimer.html#path_C
-->
<defs>
<pattern id="Pat01" width="10" height="10" patternUnits="userSpaceOnUse">
	<rect width="10" height="10" fill="#FFFFFF" stroke="#000000" stroke-width="0.1"/>
</pattern>
</defs>


<rect x="20" y="50" width="300" height="300" fill="url(#Pat01)"/>


<path d="M20,50 H320 V350 H20 Z" fill="none" stroke="none" stroke-width="0.5" stroke-dasharray="2 2"/>


<path fill="none" id="control-path" stroke="#E8C48E"/>
<path stroke="red" fill="none" id="bezier-path" stroke-width="1.2"/>

<path d="" fill="none" id="t-path-template"/>

<svg x="0" y="0" id="p-template">
<circle r="4" fill="white" stroke="#E8C48E" stroke-width="1" cx="20" cy="20" style="cursor: pointer"/>
<text x="12" y="12" style="font-size:16px;font-weight:bold">1</text>
</svg>

<circle r="4" fill="red" stroke="red" id="marker" stroke-width="1" cx="-10" cy="-10"/>

<svg>
<image xlink:href="play.png" x="5" y="5" style="cursor:pointer" width="30" height="30" id="run-button"/>
<text x="38" y="27" style="font-size:18px;font-family:'DejaVu Sans Mono', 'Lucida Console', 'Menlo', 'Monaco', Lucida Console, sans-serif">t:<tspan id="t-value">1</tspan></text>
</svg>

<script><![CDATA[
	let xmlns = "http://www.w3.org/2000/svg";
	let xlinkns  = "http://www.w3.org/1999/xlink";

	let box = {left:20, top: 50, right: 320, bottom: 350 };

	if (location.search.match('small=1')) {
	  box = {left:20, top: 50, right: 120, bottom: 150 };
	}

	document.documentElement.ondragstart = function() {
	  return false;
	};

	let pointsIn = location.search.match(/p=(.*?)($|&)/)[1];

	// don't show a piece of control path between P2 and P3
	let hideMiddleControlPath = location.search.match('nocpath=1');

	pointsIn = pointsIn.split(',');

	let points = [];

	// read points from ?p=...
	for(let i=0; i<pointsIn.length; i++) {
	  let x = box.left + (box.right - box.left)*pointsIn[i];
	  let y = box.bottom + (box.top - box.bottom)*pointsIn[++i];
	  points.push({x: x, y: y});
	}

	let bezierPath = document.getElementById("bezier-path");
	let controlPath = document.getElementById("control-path");
	//controlPath.style.display = location.search.match('nocpath=1') ? 'none' : 'block';

	let runButton = document.getElementById("run-button");
	runButton.parentNode.style.display = location.search.match('animate=1') ? 'block' : 'none';



	let tPathTemplate = document.getElementById("t-path-template");
	tPathTemplate.parentNode.removeChild(tPathTemplate);

	function drawPath() {
	  let letter;
	  switch (points.length) {
	  case 4:
	    letter = 'C';
	    break;
	  case 3:
	    letter = 'Q';
	    break;
	  default:
	    letter = 'L';
	  }
	  let bezierPathD = "M" + points[0].x + ',' + points[0].y + ' '+letter;
	  let controlPathD = "M" + points[0].x + ',' + points[0].y + ' L';

	  for(let i = 1; i < points.length; i++) {
	    bezierPathD += points[i].x + ',' + points[i].y + ' ';
	    controlPathD += points[i].x + ',' + points[i].y + ' ';
	  }
	  bezierPath.setAttribute('d', bezierPathD);
	  controlPath.setAttribute('d', controlPathD);

	  function dist(a,b) {
	    return Math.round(Math.sqrt( (a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y)));
	  }

	  if (hideMiddleControlPath) {
	    controlPath.setAttribute('stroke-dasharray', dist(points[0],points[1])+' '+dist(points[1],points[2])+' 9999 9999');
	  }

	}

	// draw control points
	function drawPoints(points) {
	  let p = document.getElementById('p-template');
	  p.removeAttribute('id');
	  p.parentNode.removeChild(p);

	  for(let i=0; i<points.length; i++) {
	    let point = p.cloneNode(true);
	    point.getElementsByTagName('text')[0].firstChild.data = i+1;
	    setPointCoords(point, i);
	    setPointHandler(point, i);
	    document.documentElement.appendChild(point);
	  }

	}

	// control points coords are shifted from Left-Upper corner a bit
	// to give them space to render
	function setPointCoords(point, i) {
	  point.setAttribute('x', points[i].x-20);
	  point.setAttribute('y', points[i].y-20);
	}

	function setPointHandler(point, i) {
	  let circle = point.getElementsByTagName('circle')[0];
	  circle.onmousedown = function() {
	    document.onmousemove = function(e) {
	      let x = e.pageX, y = e.pageY;

	      // constrain withing the box
	      if (x < box.left) x = box.left;
	      if (x > box.right) x = box.right;
	      if (y > box.bottom) y = box.bottom;
	      if (y < box.top) y = box.top;

	      points[i].x = x;
	      points[i].y = y;
	      setPointCoords(point, i);
	      drawPath();
	    }
	    document.onmouseup = function() {
	      document.onmousemove = document.onmouseup = null;
	    }
	    return false;
	  }
	}

	// draw point connectors which form the curve
	function drawT(points, t) {
	  let path = document.getElementById('t-'+points.length);

	  if (!path) {
	    path = tPathTemplate.cloneNode(true);
	    path.setAttribute('stroke', ["blue","#0a0","red"][points.length % 3]);
	    path.setAttribute('id', 't-'+points.length);
	    document.documentElement.appendChild(path);
	  }

	  let subPoints = [];
	  let x = points[0].x + (points[1].x - points[0].x)*t;
	  let y = points[0].y + (points[1].y - points[0].y)*t;

	  let tPathD = "M" + x + ',' + y + ' L';
	  subPoints.push({x, y});

	  for(let i=1; i<points.length-1; i++) {
	    let x = points[i].x + (points[i+1].x - points[i].x)*t;
	    let y = points[i].y + (points[i+1].y - points[i].y)*t;
	    subPoints.push({x: x, y: y});

	    tPathD += x + ',' + y + ' ';
	  }

	  if (points.length <= 3) {
	    let m = document.getElementById('marker');
	    let mx, my;
	    if (t == 1) {
	      mx = -10, my = -10;
	    } else {
	      mx = subPoints[0].x + (subPoints[1].x-subPoints[0].x)*t;
	      my = subPoints[0].y + (subPoints[1].y-subPoints[0].y)*t;
	    }
	    m.setAttribute('cx', mx);
	    m.setAttribute('cy', my);
	    path.setAttribute('stroke-width', 2);
	  }
	  if (points.length == 2) {
	    // only 2 points provided, special case
	    tPathD = "M"+points[0].x+","+points[0].y+" L"+x+","+y;
	  }

	  path.setAttribute('d', tPathD);

	  if (subPoints.length > 2){
	    drawT(subPoints, t);
	  }
	}

	let t = 0;
	let timer;


	// animate the curve
	function animate(complete) {

	  timer = setInterval(function() {
	    if (t>1) {
	      t = 1;
	    }
	    //bezierPath.setAttribute('stroke-dasharray', t*bezierPath.getTotalLength()+' '+bezierPath.getTotalLength());
	    drawT(points, t);

	    document.getElementById('t-value').firstChild.nodeValue = t==0 ? 0 : t == 1 ? 1 : t.toFixed(3);
	/*
	    if (t >= 0.5) {
	      clearInterval(timer);
	      runButton.parentNode.style.display = 'none';
	      return;
	    }
	*/
	    if (t == 1) {
	      clearInterval(timer);
	      timer = 0;
	      complete && complete();
	      return;
	    }

	    t += 0.005;
	  }, 30);
	}

	function animationDone() {
	  for(let i=1; i<=points.length; i++) {
	    let path = document.getElementById('t-'+i);
	    path && document.documentElement.removeChild(path);
	  }
	  t = 0;
	  runButton.setAttributeNS(xlinkns, 'xlink:href', 'play.png');
	}

	runButton.onclick = onAnimate;

	function onAnimate() {
	  if (timer) {
	    // animation in action
	    runButton.setAttributeNS(xlinkns, 'xlink:href', 'play.png');
	    clearInterval(timer);
	    timer = 0;
	    return;
	  }

	  runButton.setAttributeNS(xlinkns, 'xlink:href', 'pause.png');
	  animate(animationDone)
	}

	drawPath();
	drawPoints(points);


//]]></script>

</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 0000000000..2318e2c035
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 0000000000..91155c0997
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 89%
rename from 3-animation/2-css-animations/article.md
rename to 7-animation/2-css-animations/article.md
index 518b8a2d5e..c4b1e49fc9 100644
--- a/3-animation/2-css-animations/article.md
+++ b/7-animation/2-css-animations/article.md
@@ -2,7 +2,11 @@
 
 CSS 动画可以在不借助 Javascript 的情况下做出一些简单的动画效果。
 
+<<<<<<< HEAD:3-animation/2-css-animations/article.md
 你也可以通过 Javascript 控制 CSS 动画，使用少量的代码，就能让动画表现更加出色。
+=======
+JavaScript can be used to control CSS animation and make it even better with a little of code.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/2-css-animations/article.md
 
 ## CSS 过渡（transition）[#css-transition]
 
@@ -40,7 +44,11 @@ CSS 过渡的理念非常简单，我们只需要定义某一个属性以及如
 </script>
 ```
 
+<<<<<<< HEAD:3-animation/2-css-animations/article.md
 CSS 提供了五个属性来描述一个过渡：
+=======
+There are 4 properties to describe CSS transitions:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/2-css-animations/article.md
 
 - `transition-property`
 - `transition-duration`
@@ -260,9 +268,21 @@ CSS 提供几条内置的曲线：`linear`、`ease`、`ease-in`、`ease-out` 和
 
 时间函数 `steps(number of steps[, start/end])` 允许你让动画分段进行，`number of steps` 表示需要拆分为多少段。
 
+<<<<<<< HEAD:3-animation/2-css-animations/article.md
 让我们通过一个数字的例子来演示一下。我们将会让数字以离散的方式变化，而不是以连续的方式。
 
 为了达到效果，我们把动画拆分为 9 段：
+=======
+Let's see that in an example with digits.
+
+Here's a list of digits, without any animations, just as a source:
+
+[codetabs src="step-list"]
+
+We'll make the digits appear in a discrete way by making the part of the list outside of the red "window" invisible and shifting the list to the left with each step.
+
+There will be 9 steps, a step-move for each digit:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/2-css-animations/article.md
 
 ```css
 #stripe.animate  {
@@ -271,11 +291,19 @@ CSS 提供几条内置的曲线：`linear`、`ease`、`ease-in`、`ease-out` 和
 }
 ```
 
+<<<<<<< HEAD:3-animation/2-css-animations/article.md
 `step(9, start)` 生效时：
 
 [codetabs src="step"]
 
 `steps` 的第一个参数表示段数。这个过渡动画将会被拆分为 9 个部分（每个占 10%）。时间间隔也会以同样的方式被拆分：9 秒会被分割为多个时长 1 秒的间隔。
+=======
+In action:
+
+[codetabs src="step"]
+
+The first argument of `steps(9, start)` is the number of steps. The transform will be split into 9 parts (10% each). The time interval is automatically divided into 9 parts as well, so `transition: 9s` gives us 9 seconds for the whole animation – 1 second per digit.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/2-css-animations/article.md
 
 第二个参数可以取 `start` 或 `end` 两者其一。
 
@@ -301,7 +329,11 @@ CSS 提供几条内置的曲线：`linear`、`ease`、`ease-in`、`ease-out` 和
 - ...
 - `9s` —— `-90%`
 
+<<<<<<< HEAD:3-animation/2-css-animations/article.md
 `step(9, end)` 生效时：
+=======
+Here's `step(9, end)` in action (note the pause between the first digit change):
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/2-css-animations/article.md
 
 [codetabs src="step-end"]
 
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 0000000000..0b1e53bb28
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 0000000000..fa79639186
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 0000000000..ebe51a8a9a
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 0000000000..2b444d66a7
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 0000000000..e0b179b6bf
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 0000000000..14726b33cf
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 0000000000..df182377ac
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 0000000000..2d6e7ddbf5
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 0000000000..c07ed1234d
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 0000000000..b49506a146
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 0000000000..37f5376b7b
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 0000000000..a77eb10368
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/7-animation/2-css-animations/step-list.view/index.html b/7-animation/2-css-animations/step-list.view/index.html
new file mode 100644
index 0000000000..d7931f5e28
--- /dev/null
+++ b/7-animation/2-css-animations/step-list.view/index.html
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset="utf-8">
+  <link rel="stylesheet" href="style.css">
+</head>
+
+<body>
+
+  <div id="digit"><div id="stripe">0123456789</div></div>
+
+</body>
+</html>
diff --git a/7-animation/2-css-animations/step-list.view/style.css b/7-animation/2-css-animations/step-list.view/style.css
new file mode 100644
index 0000000000..a934e83406
--- /dev/null
+++ b/7-animation/2-css-animations/step-list.view/style.css
@@ -0,0 +1,9 @@
+#digit {
+  border: 1px solid red;
+  width: 1.2em;
+}
+
+#stripe {
+  display: inline-block;
+  font: 32px monospace;
+}
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 0000000000..97b7229444
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 0000000000..40e8947fce
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/7-animation/3-js-animation/1-animate-ball/solution.md b/7-animation/3-js-animation/1-animate-ball/solution.md
new file mode 100644
index 0000000000..5d3f08eefb
--- /dev/null
+++ b/7-animation/3-js-animation/1-animate-ball/solution.md
@@ -0,0 +1,19 @@
+To bounce we can use CSS property `top` and `position:absolute` for the ball inside the field with `position:relative`.
+
+The bottom coordinate of the field is `field.clientHeight`. The CSS `top` property refers to the upper edge of the ball. So it should go from `0` till `field.clientHeight - ball.clientHeight`, that's the final lowest position of the upper edge of the ball.
+
+To to get the "bouncing" effect we can use the timing function `bounce` in `easeOut` mode.
+
+Here's the final code for the animation:
+
+```js
+let to = field.clientHeight - ball.clientHeight;
+
+animate({
+  duration: 2000,
+  timing: makeEaseOut(bounce),
+  draw(progress) {
+    ball.style.top = to * progress + 'px'
+  }
+});
+```
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/7-animation/3-js-animation/2-animate-ball-hops/task.md b/7-animation/3-js-animation/2-animate-ball-hops/task.md
new file mode 100644
index 0000000000..fdc26c8da0
--- /dev/null
+++ b/7-animation/3-js-animation/2-animate-ball-hops/task.md
@@ -0,0 +1,13 @@
+importance: 5
+
+---
+
+# Animate the ball bouncing to the right
+
+Make the ball bounce to the right. Like this:
+
+[iframe height=250 src="solution"]
+
+Write the animation code. The distance to the left is `100px`.
+
+Take the solution of the previous task <info:task/animate-ball> as the source.
diff --git a/3-animation/3-js-animation/article.md b/7-animation/3-js-animation/article.md
similarity index 79%
rename from 3-animation/3-js-animation/article.md
rename to 7-animation/3-js-animation/article.md
index 7ee72eb118..885566d432 100644
--- a/3-animation/3-js-animation/article.md
+++ b/7-animation/3-js-animation/article.md
@@ -4,20 +4,31 @@ JavaScript 动画可以处理 CSS 无法处理的事情。
 
 例如，沿着具有与 Bezier 曲线不同的时序函数的复杂路径移动，或者实现画布上的动画。
 
+<<<<<<< HEAD:3-animation/3-js-animation/article.md
 ## 使用 setInterval
 
 从 HTML/CSS 的角度来看，动画是 style 属性的逐渐变化。例如，将 `style.left` 从 `0px` 变化到 `100px` 可以移动元素。
 
 如果我们用 `setInterval` 每秒做 50 次小变化，看起来会更流畅。电影也是这样的原理：每秒 24 帧或更多帧足以使其看起来流畅。
+=======
+## Using setInterval
+
+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 frames per second is enough to make it look smooth.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/3-js-animation/article.md
 
 伪代码如下：
 
 ```js
+<<<<<<< HEAD:3-animation/3-js-animation/article.md
 let delay = 1000 / 50; // 每秒 50 帧
+=======
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/3-js-animation/article.md
 let timer = setInterval(function() {
   if (animation complete) clearInterval(timer);
-  else increase style.left
-}, delay)
+  else increase style.left by 2px
+}, 20); // change by 2px every 20ms, about 50 frames per second
 ```
 
 更完整的动画示例：
@@ -50,15 +61,25 @@ function draw(timePassed) {
 
 [codetabs height=200 src="move"]
 
+<<<<<<< HEAD:3-animation/3-js-animation/article.md
 ## 使用 requestAnimationFrame
+=======
+## Using requestAnimationFrame
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/3-js-animation/article.md
 
 假设我们有几个同时运行的动画。
 
+<<<<<<< HEAD:3-animation/3-js-animation/article.md
 如果我们单独运行它们，每个都有自己的 `setInterval(..., 20)`，那么浏览器必须以比 `20ms` 更频繁的速度重绘。
 
 每个 `setInterval` 每 `20ms` 触发一次，但它们相互独立，因此 `20ms` 内将有多个独立运行的重绘。
 
 这几个独立的重绘应该组合在一起，以使浏览器更加容易处理。
+=======
+If we run them separately, then even though each one has `setInterval(..., 20)`, then the browser would have to repaint much more often than every `20ms`.
+
+That's because they have different starting time, so "every 20ms" differs between different animations. The intervals are not aligned. So we'll have several independent runs within `20ms`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/3-js-animation/article.md
 
 换句话说，像下面这样：
 
@@ -70,19 +91,31 @@ setInterval(function() {
 }, 20)
 ```
 
+<<<<<<< HEAD:3-animation/3-js-animation/article.md
 ……比这样更好：
+=======
+...Is lighter than three independent calls:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/3-js-animation/article.md
 
 ```js
-setInterval(animate1, 20);
-setInterval(animate2, 20);
+setInterval(animate1, 20); // independent animations
+setInterval(animate2, 20); // in different places of the script
 setInterval(animate3, 20);
 ```
 
+<<<<<<< HEAD:3-animation/3-js-animation/article.md
 还有一件事需要记住。有时当 CPU 过载时，或者有其他原因需要降低重绘频率。例如，如果浏览器选项卡被隐藏，那么绘图完全没有意义。
 
 有一个标准[动画时序](http://www.w3.org/TR/animation-timing/)提供了 `requestAnimationFrame` 函数。
 
 它解决了所有这些问题，甚至更多其它的问题。
+=======
+These several independent redraws should be grouped together, to make the redraw easier for the browser and hence load less CPU load and look smoother.
+
+There's one more thing to keep in mind. Sometimes when CPU is overloaded, or there are other reasons to redraw less often (like when the browser tab is hidden), so we really shouldn't run it every `20ms`.
+
+But how do we know about that in JavaScript? There's a specification [Animation timing](http://www.w3.org/TR/animation-timing/) that provides the function `requestAnimationFrame`. It addresses all these issues and even more.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/3-js-animation/article.md
 
 语法：
 ```js
@@ -103,7 +136,11 @@ cancelAnimationFrame(requestId);
 
 通常 `callback` 很快就会运行，除非 CPU 过载或笔记本电量消耗殆尽，或者其他原因。
 
+<<<<<<< HEAD:3-animation/3-js-animation/article.md
 下面的代码显示了 `requestAnimationFrame` 的前 10 次运行之间的时间间隔。通常是 10-20ms：
+=======
+The code below shows the time between first 10 runs for `requestAnimationFrame`. Usually it's 10-20ms:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/3-js-animation/article.md
 
 ```html run height=40 refresh
 <script>
@@ -417,7 +454,11 @@ bounceEaseInOut = makeEaseInOut(bounce);
 
 ## 总结
 
+<<<<<<< HEAD:3-animation/3-js-animation/article.md
 JavaScript 动画应该通过 `requestAnimationFrame` 实现。该内置方法允许设置回调函数，以便在浏览器准备重绘时运行。那通常很快，但确切的时间取决于浏览器。
+=======
+For animations that CSS can't handle well, or those that need tight control, JavaScript can help. JavaScript animations should be implemented via `requestAnimationFrame`. That built-in method allows to setup a callback function to run when the browser will be preparing a repaint. Usually that's very soon, but the exact time depends on the browser.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:7-animation/3-js-animation/article.md
 
 当页面在后台时，根本没有重绘，因此回调将不会运行：动画将被暂停并且不会消耗资源。那很棒。
 
diff --git a/7-animation/3-js-animation/back.png b/7-animation/3-js-animation/back.png
new file mode 100644
index 0000000000..7a5d9a6fb2
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 0000000000..dc90e1fcfc
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 0000000000..0b1e53bb28
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 0000000000..fa79639186
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 0000000000..5c867fd7d3
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 0000000000..0527e4597c
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 0000000000..2d3c6772e5
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 0000000000..5984fdb606
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 0000000000..51663c4319
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 0000000000..55fdbf3771
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 0000000000..db9c112a3f
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 0000000000..46c50779a8
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 0000000000..e19711c36c
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 0000000000..652dd175c5
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 0000000000..c757cb0e3a
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 0000000000..b170e3209d
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 0000000000..a71b91ba24
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 0000000000..0e6a305b12
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/8-web-components/1-webcomponents-intro/article.md b/8-web-components/1-webcomponents-intro/article.md
new file mode 100644
index 0000000000..a69cc3fc5c
--- /dev/null
+++ b/8-web-components/1-webcomponents-intro/article.md
@@ -0,0 +1,76 @@
+# 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 0000000000..56c1271121
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 0000000000..c65b124502
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 0000000000..9a3793f357
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 0000000000..9624379d5b
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 0000000000..9d59650c01
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 0000000000..5abd4a2d84
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 0000000000..a9eacc8803
--- /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 0000000000..e1dd85096e
--- /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 0000000000..a53d72e001
--- /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 0000000000..4fab99cb25
--- /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 0000000000..878120241d
--- /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 0000000000..e2fe2b69fa
--- /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 0000000000..4fab99cb25
--- /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 0000000000..1feb7490ab
--- /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 0000000000..85434c75af
--- /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 0000000000..c07cb6d436
--- /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 0000000000..fafc4754c9
--- /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 standardized to allow us, developers, to do the similar thing.
+
+Further 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 must 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 0000000000..126206107b
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 0000000000..179d132ec4
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 0000000000..f99285e293
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 0000000000..8f7bb25130
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 0000000000..25aada6fc4
--- /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 HTML markup templates. 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 HTML 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": styles are not applied, scripts are not executed, `<video autoplay>` is not run, etc.
+
+The content becomes live (styles apply, scripts run etc) when we insert it into the document.
+
+## 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`, as it's `DocumentFragment`, 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 HTML 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>` element does not feature any iteration mechanisms, data binding or variable substitutions, but we can implement 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 0000000000..6ddc44245d
--- /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 0000000000..86b31d860b
--- /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 0000000000..8b9983b3c7
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 0000000000..83e12d44ad
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 0000000000..66e5cc13d9
--- /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 0000000000..14e310a556
--- /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 0000000000..f572ed3d41
--- /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 54%
rename from 5-regular-expressions/01-regexp-introduction/article.md
rename to 9-regular-expressions/01-regexp-introduction/article.md
index 21d33804fa..454d4d66f8 100644
--- a/5-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -1,5 +1,6 @@
 # 模式（Patterns）和修饰符（flags）
 
+<<<<<<< HEAD:5-regular-expressions/01-regexp-introduction/article.md
 正则表达式是搜索和替换字符串的一种强大方式。
 
 在 JavaScript 中，正则表达式通过内置的“RegExp”类的对象来实现，并与字符串集成。
@@ -9,6 +10,9 @@
 ## 正则表达式
 
 正则表达式（可叫作“regexp”或者“reg”）包含 **模式** 和可选的 **修饰符**。
+=======
+A regular expression (also "regexp", or just "reg") consists of a *pattern* and optional *flags*.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/01-regexp-introduction/article.md
 
 创建一个正则表达式对象有两种语法。
 
@@ -53,7 +57,11 @@ alert( str.search(substr) ); // 2
 
 所以搜索 `pattern:/love/` 与搜索 `"love"` 是等价的。
 
+<<<<<<< HEAD:5-regular-expressions/01-regexp-introduction/article.md
 但这只是暂时的。很快我们就会接触更复杂的正则表达式，其搜索功能将更强大。
+=======
+But that's only for now. Soon we'll create more complex regular expressions with much more searching power.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/01-regexp-introduction/article.md
 
 ```smart header="配色"
 本文中的配色方案如下：
@@ -64,19 +72,33 @@ alert( str.search(substr) ); // 2
 ```
 
 
+<<<<<<< HEAD:5-regular-expressions/01-regexp-introduction/article.md
 ````smart header="什么时候使用 `new RegExp`?"
 通常我们使用的都是简短语法 `/.../`。但是它不接受任何变量插入，所以我们必须在写代码的时候就知道确切的 regexp。
 
 另一方面，`new RegExp` 允许从字符串中动态地构造模式。
 
 所以我们可以找出需要搜索的字段，然后根据搜索字段创建 `new RegExp`：
+=======
+````smart header="When to use `new RegExp`?"
+Normally we use the short syntax `/.../`. But it does not support variable insertions `${...}`.
+
+On the other hand, `new RegExp` allows to construct a pattern dynamically from a string, so it's more flexible.
+
+Here's an example of a dynamically generated regexp:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/01-regexp-introduction/article.md
 
 ```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}>`);
 
+<<<<<<< HEAD:5-regular-expressions/01-regexp-introduction/article.md
 // 找到用户想要的任何东西
 alert( "I love JavaScript".search(regexp));
+=======
+// finds <h2> by default
+alert( "<h1> <h2> <h3>".search(regexp));
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/01-regexp-introduction/article.md
 ```
 ````
 
@@ -85,7 +107,11 @@ alert( "I love JavaScript".search(regexp));
 
 正则表达式的修饰符可能会影响搜索结果。
 
+<<<<<<< HEAD:5-regular-expressions/01-regexp-introduction/article.md
 在 JavaScript 中，有 5 个修饰符：
+=======
+There are only 6 of them in JavaScript:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/01-regexp-introduction/article.md
 
 `i`
 : 使用此修饰符后，搜索时不区分大小写: `A` 和 `a` 没有区别（具体看下面的例子）。
@@ -94,36 +120,65 @@ alert( "I love JavaScript".search(regexp));
 : 使用此修饰符后，搜索时会查找所有的匹配项，而不只是第一个（在下一章会讲到）。
 
 `m`
+<<<<<<< HEAD:5-regular-expressions/01-regexp-introduction/article.md
 : 多行模式（详见章节 <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>).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/01-regexp-introduction/article.md
 
 `u`
 : 开启完整的 unicode 支持。该修饰符能够修正对于代理对的处理。更详细的内容见章节 <info:regexp-unicode>。
 
 `y`
+<<<<<<< HEAD:5-regular-expressions/01-regexp-introduction/article.md
 : 粘滞模式（详见 [下一章节](info:regexp-methods#y-flag)）
+=======
+: Sticky mode (covered in the chapter <info:regexp-sticky>)
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/01-regexp-introduction/article.md
 
+We'll cover all these flags further in the tutorial.
 
+<<<<<<< HEAD:5-regular-expressions/01-regexp-introduction/article.md
 ## “i”修饰符
 
 最简单的修饰符就是 `i` 了。
 
 示例代码如下：
+=======
+For now, the simplest flag is `i`, here's an example:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/01-regexp-introduction/article.md
 
 ```js run
 let str = "I love JavaScript!";
 
+<<<<<<< HEAD:5-regular-expressions/01-regexp-introduction/article.md
 alert( str.search(/LOVE/) ); // -1（没找到）
 alert( str.search(/LOVE/i) ); // 2
 ```
 
 1. 第一个搜索返回的是 `-1`（也就是没找到），因为搜索默认是区分大小写的。
 2. 使用修饰符 `pattern:/LOVE/i`，在字符串的第 2 个位置上搜索到了 `match:love`。
+=======
+alert( str.search(/LOVE/i) ); // 2 (found lowercased)
+
+alert( str.search(/LOVE/) ); // -1 (nothing found without 'i' flag)
+```
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/01-regexp-introduction/article.md
 
 相比与简单的子字符串查找，`i` 修饰符已经让正则表达式变得更加强大了。但是这还不够。我们会在下一章节讲述其它修饰符和特性。
 
 
 ## 总结
 
+<<<<<<< HEAD:5-regular-expressions/01-regexp-introduction/article.md
 - 一个正则表达式包含模式和可选修饰符：`g`、`i`、`m`、`u`、`y`。
 - 如果不使用我们在后面将要学到的修饰符和特殊标志，正则表达式的搜索就等同于子字符串查找。
 - `str.search(regexp)` 方法返回的是找到的匹配项的索引位置，如果没找到则返回 `-1`。
+=======
+- 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. In the next chapter we'll see other methods.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/01-regexp-introduction/article.md
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 0000000000..f66a9c7943
--- /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.
+
+So, here are general recipes, the details to follow:
+
+**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 can continue reading this chapter to get the details about every method... But if you're reading for the first time, then you probably want to know more about regexps. So you can move 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 (first match at zero position)
+```
+
+**The important limitation: `search` only finds  the first match.**
+
+We can't find next matches 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)
+
+This is a generic method for searching and replacing, one of most useful ones. The swiss army knife for searching and replacing.  
+
+We can use it without regexps, to search and replace a substring:
+
+```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 1st, 2nd and so on 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 the search in another string may 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/9-regular-expressions/03-regexp-character-classes/article.md b/9-regular-expressions/03-regexp-character-classes/article.md
new file mode 100644
index 0000000000..2f415afd8e
--- /dev/null
+++ b/9-regular-expressions/03-regexp-character-classes/article.md
@@ -0,0 +1,269 @@
+# Character classes
+
+Consider a practical task -- we have a phone number `"+7(903)-123-45-67"`, and we need to turn it into pure numbers: `79035419441`.
+
+To do so, we can find and remove anything that's not a number. Character classes can help with that.
+
+A character class is a special notation that matches any symbol from a certain set.
+
+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";
+
+let reg = /\d/;
+
+alert( str.match(reg) ); // 7
+```
+
+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 find all digits:
+
+```js run
+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
+
+alert( str.match(reg).join('') ); // 79035419441
+```
+
+That was a character class for digits. There are other character classes as well.
+
+Most used are:
+
+`\d` ("d" is from "digit")
+: A digit: a character from `0` to `9`.
+
+`\s` ("s" is from "space")
+: A space symbol: that includes spaces, tabs, newlines.
+
+`\w` ("w" is from "word")
+: A "wordly" character: either a letter of English alphabet or a digit or an underscore. Non-Latin 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 a"`.
+
+**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:
+
+```js run
+let str = "CSS4 is cool";
+let reg = /CSS\d/
+
+alert( str.match(reg) ); // CSS4
+```
+
+Also we can use many character classes:
+
+```js run
+alert( "I love HTML5!".match(/\s\w\w\w\w\d/) ); // ' HTML5'
+```
+
+The match (each character class corresponds to one result character):
+
+![](love-html5-classes.png)
+
+## Word boundary: \b
+
+A word boundary `pattern:\b` -- is a special character class.
+
+It does not denote a character, but rather a boundary between characters.
+
+For instance, `pattern:\bJava\b` matches `match:Java` in the string `subject:Hello, Java!`, but not in the script `subject:Hello, JavaScript!`.
+
+```js run
+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 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 is a word boundary, that is one of three variants:
+
+- 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`, 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 (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.
+
+Usually we use `\b` to find standalone English words. So that if we want `"Java"` language then `pattern:\bJava\b` finds exactly a standalone word and ignores it when it's a part of another word, e.g. it won't match `match:Java` in `subject:JavaScript`.
+
+Another example: a regexp `pattern:\b\d\d\b` looks for standalone two-digit numbers. In other words, it requires that before and after `pattern:\d\d` must be a symbol different from `\w` (or beginning/end of the string).
+
+```js run
+alert( "1 23 456 78".match(/\b\d\d\b/g) ); // 23,78
+```
+
+```warn header="Word boundary doesn't work for non-Latin alphabets"
+The word boundary check `\b` tests for a boundary between `\w` and something else. But `\w` means an English letter (or a digit or an underscore), so the test won't work for other characters (like cyrillic or hieroglyphs).
+
+Later we'll come by Unicode character classes that allow to solve the similar task for different languages.
+```
+
+
+## Inverse classes
+
+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:
+
+`\D`
+: Non-digit: any character except `\d`, for instance a letter.
+
+`\S`
+: Non-space: any character except `\s`, for instance a letter.
+
+`\W`
+: Non-wordly character: anything but `\w`.
+
+`\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`.
+
+One way was to match all digits and join them:
+
+```js run
+let str = "+7(903)-123-45-67";
+
+alert( str.match(/\d/g).join('') ); // 79031234567
+```
+
+An alternative, shorter way is to find non-digits `\D` and remove them from the string:
+
+
+```js run
+let str = "+7(903)-123-45-67";
+
+alert( str.replace(/\D/g, "") ); // 79031234567
+```
+
+## Spaces are 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 doesn't take spaces into account, it may fail to work.
+
+Let's try to find digits separated by a dash:
+
+```js run
+alert( "1 - 5".match(/\d-\d/) ); // null, no match!
+```
+
+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
+```
+
+**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.
+
+## A dot is any character
+
+The dot `"."` is a special character class that matches "any character except a newline".
+
+For instance:
+
+```js run
+alert( "Z".match(/./) ); // Z
+```
+
+Or in the middle of a regexp:
+
+```js run
+let reg = /CS.4/;
+
+alert( "CSS4".match(reg) ); // CSS4
+alert( "CS-4".match(reg) ); // CS-4
+alert( "CS 4".match(reg) ); // CS 4 (space is also a character)
+```
+
+Please note that the dot means "any character", but not the "absense of a character". There must be a character to match it:
+
+```js run
+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, `pattern:A.B` matches `match:A`, and then `match:B` with any character between them, except a newline.
+
+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
+
+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!
+
+The Unicode encoding, used by JavaScript for strings, provides many properties for characters, like: which language the letter belongs to (if a letter) it is it a punctuation sign, etc.
+
+Modern JavaScript allows to use these properties in regexps to look for characters, for instance:
+
+- 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, such as `$`, `€` or another: `pattern:\p{Currency_Symbol}` or `pattern:\p{sc}`.
+- ...And much more. Unicode has a lot of character categories that we can select from.
+
+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 0000000000..46fc686bac
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 0000000000..9beafe7077
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 0000000000..8f9daefddb
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 0000000000..438c6bc220
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 0000000000..909cd48560
--- /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
+```
+
+The search worked with `pattern:/\d\.\d/`, but with `new RegExp("\d\.\d")` it doesn't work, 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 the search 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 87%
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
index ccfbbc4fd6..534ac97f77 100644
--- a/5-regular-expressions/05-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/05-regexp-character-sets-and-ranges/article.md
@@ -15,7 +15,11 @@ alert( "Mop top".match(/[tm]op/gi) ); // "Mop", "top"
 
 请注意尽管在集合中有多个字符，但它们在匹配中只会对应其中的一个。
 
+<<<<<<< HEAD:5-regular-expressions/05-regexp-character-sets-and-ranges/article.md
 所以下面的示例并不会匹配上：
+=======
+So the example below gives no matches:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/05-regexp-character-sets-and-ranges/article.md
 
 ```js run
 // 查找 “V”，然后匹配 [o 或者 i]，之后再匹配 “la”
@@ -58,7 +62,11 @@ alert( "Exception 0xAF".match(/x[0-9A-F][0-9A-F]/g) ); // xAF
 
 比如说，我们想要匹配所有单词字符或者短划线，类似像 “twenty-third” 之类的单词。我们不能使用 `pattern:\w+` 来匹配，因为 `pattern:\w` 并不包含一个短划线。但是我们可以使用 `pattern:[\w-]` 来查找。
 
+<<<<<<< HEAD:5-regular-expressions/05-regexp-character-sets-and-ranges/article.md
 我们也可以使用字符类的组合来覆盖每个可能的字符，比如说像 `pattern:[\s\S]`。这会匹配任何空格或者非空格的字符 —— 也就是任何字符。这个匹配范围会比符号点 `"."` 的范围更广，因为点匹配只能匹配除了换行符之外的所有字符。
+=======
+We also can use several classes, for example `pattern:[\s\S]` matches spaces or non-spaces -- any character. That's wider than a dot `"."`, because the dot matches any character except a newline (unless `s` flag is set).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb: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 56%
rename from 5-regular-expressions/07-regexp-quantifiers/article.md
rename to 9-regular-expressions/07-regexp-quantifiers/article.md
index a5583869af..fa5714edc5 100644
--- a/5-regular-expressions/07-regexp-quantifiers/article.md
+++ b/9-regular-expressions/07-regexp-quantifiers/article.md
@@ -1,17 +1,34 @@
 # 量词 `+,*,?` 和 `{n}`
 
+<<<<<<< HEAD:5-regular-expressions/07-regexp-quantifiers/article.md
 假设我们有一个字符串 `+7(903)-123-45-67`，并且想要找到它包含的所有数字。但与之前不同的是，我们对单个数字不感兴趣，只对全数感兴趣：`7, 903, 123, 45, 67`。
 
 数字是一个或多个 `\d` 的序列。用来形容我们所需要的数量的词被称为**量词**。
+=======
+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`. To mark how many we need, we need to append a *quantifier*.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/07-regexp-quantifiers/article.md
 
 ## 数量 {n}
 
+<<<<<<< HEAD:5-regular-expressions/07-regexp-quantifiers/article.md
 最明显的量词便是一对引号间的数字：`pattern:{n}`。在一个字符（或一个字符类等等）后跟着一个量词，用来指出我们具体需要的数量。
 
 它有更高级的格式，用一个例子来说明：
 
 确切的位数：`{5}`
 : `pattern:\d{5}` 表示 5 位的数字，如同 `pattern:\d\d\d\d\d`。
+=======
+The simplest quantifier is a number in curly braces: `pattern:{n}`.
+
+A quantifier is appended to a character (or a character class, or a `[...]` set etc) and specifies how many we need.
+
+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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/07-regexp-quantifiers/article.md
 
     接下来的例子将会查找一个五位数的数字：
 
@@ -21,20 +38,37 @@
 
     我们可以添加 `\b` 来排除更多位数的数字：`pattern:\b\d{5}\b`。
 
+<<<<<<< HEAD:5-regular-expressions/07-regexp-quantifiers/article.md
 某个范围的位数：`{3,5}`
 : 我们可以将限制范围的数字放入括号中，来查找位数为 3 至 5 位的数字：`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}`
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/07-regexp-quantifiers/article.md
 
     ```js run
     alert( "I'm not 12, but 1234 years old".match(/\d{3,5}/) ); // "1234"
     ```
 
+<<<<<<< HEAD:5-regular-expressions/07-regexp-quantifiers/article.md
     我们可以省略上限。那么正则表达式 `pattern:\d{3,}` 就会查找位数大于或等于 3 的数字：
+=======
+    We can omit the upper limit.
+
+    Then a regexp `pattern:\d{3,}` looks for sequences of digits of length `3` or more:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/07-regexp-quantifiers/article.md
 
     ```js run
     alert( "I'm not 12, but 345678 years old".match(/\d{3,}/) ); // "345678"
     ```
 
+<<<<<<< HEAD:5-regular-expressions/07-regexp-quantifiers/article.md
 对于字符串 `+7(903)-123-45-67` 来说，我们如果需要一个或多个连续的数字，就使用 `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,}`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/07-regexp-quantifiers/article.md
 
 ```js run
 let str = "+7(903)-123-45-67";
@@ -46,7 +80,11 @@ alert(numbers); // 7,903,123,45,67
 
 ## 缩写
 
+<<<<<<< HEAD:5-regular-expressions/07-regexp-quantifiers/article.md
 大多数常用的量词都可以有缩写：
+=======
+There are shorthands for most used quantifiers:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/07-regexp-quantifiers/article.md
 
 `+`
 : 代表“一个或多个”，相当于 `{1,}`。
@@ -64,7 +102,11 @@ alert(numbers); // 7,903,123,45,67
 
     例如，模式 `pattern:ou?r` 查找 `match:o`，后跟零个或一个 `match:u`，然后是 `match:r`。
 
+<<<<<<< HEAD:5-regular-expressions/07-regexp-quantifiers/article.md
     所以他能够在 `subject:color` 中找到 `match:or`，以及在 `subject:colour` 中找到 `match:our`：
+=======
+    So, `pattern:colou?r` finds both `match:color` and `match:colour`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/07-regexp-quantifiers/article.md
 
     ```js run
     let str = "Should I write color or colour?";
@@ -75,7 +117,11 @@ alert(numbers); // 7,903,123,45,67
 `*`
 ：代表着“零个或多个”，相当于 `{0,}`。也就是说，这个字符可以多次出现或不出现。
 
+<<<<<<< HEAD:5-regular-expressions/07-regexp-quantifiers/article.md
     接下来的例子将要寻找一个后跟任意数量的 0 的数字：
+=======
+    For example, `pattern:\d0*` looks for a digit followed by any number of zeroes:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/07-regexp-quantifiers/article.md
 
     ```js run
     alert( "100 10 1".match(/\d0*/g) ); // 100, 10, 1
@@ -85,11 +131,16 @@ alert(numbers); // 7,903,123,45,67
 
     ```js run
     alert( "100 10 1".match(/\d0+/g) ); // 100, 10
+    // 1 not matched, as 0+ requires at least one zero
     ```
 
 ## 更多示例
 
+<<<<<<< HEAD:5-regular-expressions/07-regexp-quantifiers/article.md
 量词是经常被使用的。它们是构成复杂的正则表达式的主要模块之一，我们接着来看更多的例子。
+=======
+Quantifiers are used very often. They serve as the main "building block" of complex regular expressions, so let's see more examples.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/07-regexp-quantifiers/article.md
 
 正则表达式“浮点数”（带浮点的数字）：`pattern:\d+\.\d+`
 : 实现：
@@ -120,12 +171,21 @@ alert(numbers); // 7,903,123,45,67
     alert( "<h1>Hi!</h1>".match(/<\/?[a-z][a-z0-9]*>/gi) ); // <h1>, </h1>
     ```
 
+<<<<<<< HEAD:5-regular-expressions/07-regexp-quantifiers/article.md
 ```smart header="更精确意味着更复杂"
 我们能够从这些例子中看到一个共同的规则：正则表达式越精确 —— 它就越长且越复杂。
 
 例如，HTML 标记能用一个简单的正则表达式：`pattern:<\w+>`。
 
 因为 `pattern:\w` 代表任意英文字母或数字或 `'_'`，这个正则表达式也能够匹配非标注的内容，比如 `match:<_>`。但它要比 `pattern:<[a-z][a-z0-9]*>` 简单很多。
+=======
+```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, for HTML tags we could use a simpler regexp: `pattern:<\w+>`.
+
+...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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/07-regexp-quantifiers/article.md
 
 我们能够接受 `pattern:<\w+>` 或者我们需要 `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 64%
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 05c3544bbb..e21e2aa514 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,11 @@
 
 首先想到的是 `pattern:<!--.*?-->` —— 惰性量词使得点（.）停在 `match:-->` 之前。
 
+<<<<<<< HEAD:5-regular-expressions/08-regexp-greedy-and-lazy/3-find-html-comments/solution.md
 但是在 Javascript 中，一个点（.）表示除换行符之外的任意字符。所以这是无法匹配多行注释的。
+=======
+But a dot in JavaScript means "any symbol except the newline". So multiline comments won't be found.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/08-regexp-greedy-and-lazy/3-find-html-comments/solution.md
 
 我们可以用 `pattern:[\s\S]`，而不是用点（.）来匹配“任何东西”：
 
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 53%
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
index 31bba16ba4..c42925e418 100644
--- 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
@@ -12,4 +12,8 @@ let str = '<> <a href="/"> <input type="radio" checked> <b>';
 alert( str.match(reg) ); // '<a href="/">', '<input type="radio" checked>', '<b>'
 ```
 
+<<<<<<< HEAD:5-regular-expressions/08-regexp-greedy-and-lazy/4-find-html-tags-greedy-lazy/task.md
 假设不包含 `<` 和 `>`（也包括引号），这将会简单许多。
+=======
+Here we assume that tag attributes may not contain `<` and `>` (inside squotes too), that simplifies things a bit. 
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb: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 81%
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 0fadaee274..5a4b5d2e70 100644
--- a/5-regular-expressions/08-regexp-greedy-and-lazy/article.md
+++ b/9-regular-expressions/08-regexp-greedy-and-lazy/article.md
@@ -8,6 +8,7 @@
 
 有一个文本，我们需要用书名号：`«...»` 来代替所有的引号 `"..."`。在许多国家，它们是排版的首选。
 
+<<<<<<< HEAD:5-regular-expressions/08-regexp-greedy-and-lazy/article.md
 例如：`"Hello, world"` 将会变成 `«Hello, world»`。
 
 一些国家偏爱 `„Witam, świat!”`（波兰语）甚至 `「你好，世界」`（汉语）引号。对于不同的语言环境，我们可以选择不同的替代方式，但它们都是一样的，那我们就以书名号 `«...»` 开始。
@@ -17,6 +18,15 @@
 正则表达式看上去可能是这样的：`pattern:/".+"/g`。这个表达式的意思是：我们要查找这样一个句子，一个引号后跟一个或多个字符，然后以另一个引号结尾。
 
 ...但如果我们试着在一个如此简单的例子中去应用它...
+=======
+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 `«...»`.
+
+The first thing to do is to locate quoted strings, and then we can replace them.
+
+A regular expression like `pattern:/".+"/g` (a quote, then something, then the other quote) may seem like a good fit, but it isn't!
+
+Let's try it:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/08-regexp-greedy-and-lazy/article.md
 
 ```js run
 let reg = /".+"/g;
@@ -173,7 +183,11 @@ alert( "123 456".match(/\d+ \d+?/g) ); // 123 4
 
 ## 替代方法
 
+<<<<<<< HEAD:5-regular-expressions/08-regexp-greedy-and-lazy/article.md
 在正则表达式中，通常有多种方法来达到某个相同目的。
+=======
+With regexps, there's often more than one way to do the same thing.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/08-regexp-greedy-and-lazy/article.md
 
 在用例中，我们能够在不启用懒惰模式的情况下用 `pattern:"[^"]+"` 找到带引号的字符串：
 
@@ -193,7 +207,11 @@ alert( str.match(reg) ); // witch, broom
 
 这是不同的，我们有时需要这一个，有时却需要另一个。
 
+<<<<<<< HEAD:5-regular-expressions/08-regexp-greedy-and-lazy/article.md
 让我们再来看一个使用惰性量词失败而使用这种方式正确的例子。
+=======
+**Let's see an example where lazy quantifiers fail and this variant works right.**
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/08-regexp-greedy-and-lazy/article.md
 
 例如，我们想要找到 `<a href="..." class="doc">` 形式的链接，或是任意 `href`。
 
@@ -210,7 +228,11 @@ let reg = /<a href=".*" class="doc">/g;
 alert( str.match(reg) ); // <a href="link" class="doc">
 ```
 
+<<<<<<< HEAD:5-regular-expressions/08-regexp-greedy-and-lazy/article.md
 ...但如果文本中有多个链接呢？
+=======
+It worked. But let's see what happens if there are many links in the text?
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/08-regexp-greedy-and-lazy/article.md
 
 ```js run
 let str = '...<a href="link1" class="doc">... <a href="link2" class="doc">...';
@@ -239,14 +261,22 @@ let reg = /<a href=".*?" class="doc">/g;
 alert( str.match(reg) ); // <a href="link1" class="doc">, <a href="link2" class="doc">
 ```
 
+<<<<<<< HEAD:5-regular-expressions/08-regexp-greedy-and-lazy/article.md
 现在能成功了，有两个匹配项：
+=======
+Now it seems to work, there are two matches:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/08-regexp-greedy-and-lazy/article.md
 
 ```html
 <a href="....." class="doc">    <a href="....." class="doc">
 <a href="link1" class="doc">... <a href="link2" class="doc">
 ```
 
+<<<<<<< HEAD:5-regular-expressions/08-regexp-greedy-and-lazy/article.md
 它的工作原理是 —— 在上述的解释之后，这应该是显而易见的。所以我们不停留在这些细节上，来再尝试一个例子：
+=======
+...But let's test it on one more text input:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/08-regexp-greedy-and-lazy/article.md
 
 ```js run
 let str = '...<a href="link1" class="wrong">... <p style="" class="doc">...';
@@ -256,6 +286,7 @@ let reg = /<a href=".*?" class="doc">/g;
 alert( str.match(reg) ); // <a href="link1" class="wrong">... <p style="" class="doc">
 ```
 
+<<<<<<< HEAD:5-regular-expressions/08-regexp-greedy-and-lazy/article.md
 我们会发现，这个正则表达式不仅匹配了一个链接，还匹配了包含 `<p...>` 的一段文本。
 
 为什么？
@@ -269,11 +300,26 @@ alert( str.match(reg) ); // <a href="link1" class="wrong">... <p style="" class=
     ...在哪里可以找到它呢？我们如果查看文本，就可以看到唯一的 `match:class="doc">` 是在链接之后的，在 `<p>` 中。
 
 3. 所以有了如下匹配项：
+=======
+Now it fails. The match includes not just a link, but also a lot of text after it, including `<p...>`.
+
+Why?
+
+That's what's going on:
 
-    ```html
-    <a href="..................................." class="doc">
-    <a href="link1" class="wrong">... <p style="" 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">`.
+
+But the problem is: that's already beyond the link, in another tag `<p>`. Not what we want.
+
+Here's the picture of the match aligned with the text:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/08-regexp-greedy-and-lazy/article.md
+
+```html
+<a href="..................................." class="doc">
+<a href="link1" class="wrong">... <p style="" class="doc">
+```
 
 所以，懒惰模式在这里不起作用。
 
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 0000000000..d2ed3d55ac
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 0000000000..e1e6076d33
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 0000000000..175636ced3
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 0000000000..e3c3d75919
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 0000000000..d879244a98
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 0000000000..3594f91ba6
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 0000000000..2a571b0d83
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 0000000000..9fd709e8bc
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 0000000000..ae1528aa93
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 0000000000..f17edceb08
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 0000000000..5fd767c6af
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 0000000000..10bdfb8c79
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 0000000000..af5416a729
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 0000000000..27e2725900
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 0000000000..c6dbdc9260
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 0000000000..4fdbd99a63
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 0000000000..04f91fbbaf
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 0000000000..7a28643117
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 0000000000..d2e41d458f
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 0000000000..49dc2cd8e6
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 53%
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
index adc20375a6..3a403a9c91 100755
--- 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
@@ -6,7 +6,11 @@
 
 但是，还有一种更讨巧的方法：`pattern:/#([a-f0-9]{3}){1,2}/i`。
 
+<<<<<<< HEAD:5-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
 这里我们把正则 `pattern:[a-f0-9]{3}` 放置在括号内，并且应用量词 `pattern:{1,2}`。
+=======
+Here the regexp `pattern:[a-f0-9]{3}` is in parentheses to apply the quantifier `pattern:{1,2}` to it as a whole.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
 
 实际操作：
 
@@ -15,15 +19,19 @@ let reg = /#([a-f0-9]{3}){1,2}/gi;
 
 let str = "color: #3f3; background-color: #AA00ef; and: #abcd";
 
-alert( str.match(reg) ); // #3f3 #AA0ef #abc
+alert( str.match(reg) ); // #3f3 #AA00ef #abc
 ```
 
+<<<<<<< HEAD:5-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
 不过这里有个小问题：这个模式会在 `subject:#abcd` 中找到 `match:#abc`。为了避免这种情况，我们可以在最后加上 `pattern:\b`：
+=======
+There's a minor problem here: the pattern found `match:#abc` in `subject:#abcd`. To prevent that we can add `pattern:\b` to the end:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
 
 ```js run
 let reg = /#([a-f0-9]{3}){1,2}\b/gi;
 
 let str = "color: #3f3; background-color: #AA00ef; and: #abcd";
 
-alert( str.match(reg) ); // #3f3 #AA0ef
+alert( str.match(reg) ); // #3f3 #AA00ef
 ```
diff --git a/9-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
new file mode 100644
index 0000000000..4efd6f61f8
--- /dev/null
+++ b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md
@@ -0,0 +1,14 @@
+# Find color in the format #abc or #abcdef
+
+Write a RegExp that matches colors in the format `#abc` or `#abcdef`. That is: `#` followed by 3 or 6 hexadecimal digits.
+
+Usage example:
+```js
+let reg = /your regexp/g;
+
+let str = "color: #3f3; background-color: #AA00ef; and: #abcd";
+
+alert( str.match(reg) ); // #3f3 #AA00ef
+```
+
+P.S. This should be exactly 3 or 6 hex digits: values like `#abcd` should not match.
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 0000000000..23065413ef
--- /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 60%
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 9519a9644d..e9022de542 100755
--- 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 @@
 ```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 53%
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 f4974215c8..7350d87138 100755
--- a/5-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
+++ b/9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
@@ -1,6 +1,10 @@
 回顾之前的问题，我们用 `pattern:-?\d+(\.\d+)?` 来匹配数字。
 
+<<<<<<< HEAD:5-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
 `pattern:[-+*/]` 匹配运算符。我们把 `pattern:-` 放在最前面，因为如果放在中间的话，则表示字符范围，这并不是我们想要的。
+=======
+An operator is `pattern:[-+*/]`. We put the dash `pattern:-` first, because in the middle it would mean a character range, we don't need that.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
 
 注意，在 JavaScript 中，`pattern:/.../` 中的 `/` 需要被转义。
 
@@ -20,6 +24,7 @@ alert( "1.2 + 12".match(reg) );
 
 结果包括：
 
+<<<<<<< HEAD:5-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
 - `result[0] == "1.2 + 12"`（完整匹配）
 - `result[1] == "1"`（第一个捕获组）
 - `result[2] == ".2"`（第二个捕获组 —— 小数部分）
@@ -30,6 +35,20 @@ alert( "1.2 + 12".match(reg) );
 我们只需要数字和运算符，不需要小数部分。
 
 因此，我们可以加上 `pattern:?:` 来去除多余的捕获组，例如：`pattern:(?:\.\d+)?`。
+=======
+- `result[0] == "1.2 + 12"` (full match)
+- `result[1] == "1.2"` (first group `(-?\d+(\.\d+)?)` -- the first number, including the decimal part)
+- `result[2] == ".2"` (second group`(\.\d+)?` -- the first decimal part)
+- `result[3] == "+"` (third group `([-+*\/])` -- the operator)
+- `result[4] == "12"` (forth group `(-?\d+(\.\d+)?)` -- the second number)
+- `result[5] == undefined` (fifth group `(\.\d+)?` -- the last decimal part is absent, so it's undefined)
+
+We only want the numbers and the operator, without the full match or the decimal parts.
+
+The full match (the arrays first item) can be removed by shifting the array `pattern:result.shift()`.
+
+The decimal groups can be removed by making them into non-capturing groups, by adding `pattern:?:` to the beginning: `pattern:(?:\.\d+)?`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
 
 最终答案：
 
@@ -39,7 +58,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 228f35bf56..5e9dedc573 100755
--- a/5-regular-expressions/09-regexp-groups/article.md
+++ b/9-regular-expressions/09-regexp-groups/article.md
@@ -1,11 +1,20 @@
 # 捕获组
 
+<<<<<<< HEAD:5-regular-expressions/09-regexp-groups/article.md
 正则模式的一部分可以用括号括起来 `pattern:(...)`，由此构成一个『捕获组』。
+=======
+A part of a pattern can be enclosed in parentheses `pattern:(...)`. This is called a "capturing group".
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/09-regexp-groups/article.md
 
 这有两个作用：
 
+<<<<<<< HEAD:5-regular-expressions/09-regexp-groups/article.md
 1. 当使用 [String#match](mdn:js/String/match) 或 [RegExp#exec](mdn:/RegExp/exec) 方法时，它允许你把匹配到的部分放到一个独立的数组项里面。
 2. 如果我们在括号之后加上量词，那么它会应用到这个整体，而非最后一个字符。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/09-regexp-groups/article.md
 
 ## 例子
 
@@ -30,6 +39,7 @@ john.smith@site.com.uk
 
 正则为：`pattern:[-.\w]+@([\w-]+\.)+[\w-]{2,20}`。
 
+<<<<<<< HEAD:5-regular-expressions/09-regexp-groups/article.md
 - `@` 之前的第一部分 `pattern:[-.\w]+` 可以包括单字字符、点号和中划线，比如 `match:john.smith`。
 - 接着是 `pattern:@`。
 - 然后是域名。可能是个二级域名 `site.com` 或者包括子域名 `host.site.com.uk`。我们可以通过『单词之后接一个点号』并且重复至少一次来匹配子域名 `match:mail.` 或者 `match:site.com.`，再然后是一个单词用来表示最后一部分 `match:.com` 或者 `match:.uk`。
@@ -41,21 +51,38 @@ john.smith@site.com.uk
 这条正则并不完美，但是通常来说它是有效的。它很简短，并且足以让你修正错误，以及时常出现的拼写问题。
 
 举个例子，这里我们可以找到字符串中所有的 email 地址：
+=======
+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).
+
+That regexp is not perfect, but good enough to fix errors or occasional mistypes.
+
+For instance,  we can find all emails in the string:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/09-regexp-groups/article.md
 
 ```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.
 
 ## 捕获内容 
 
 捕获括号会按从左往右的顺序标上序号。查找引擎会记住每个括号内的内容，并且允许你在模式以及替换字符串中引用它。
 
+<<<<<<< HEAD:5-regular-expressions/09-regexp-groups/article.md
 举例来说，我们可以使用一个（简化版）的模式 `pattern:<.*?>` 来查找一个 HTML 标签。一般来说，我们会希望对这个结果做些什么。
 
 如果我们把 `<...>` 里面的内容放到一对捕获括号里，那么我们通过这种方法来引用它：
+=======
+For instance, we'd like to find HTML tags `pattern:<.*?>`, and process them.
+
+Let's wrap the inner content into parentheses, like this: `pattern:<(.*?)>`.
+
+We'll get them into an array:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/09-regexp-groups/article.md
 
 ```js run
 let str = '<h1>Hello, world!</h1>';
@@ -65,7 +92,13 @@ alert( str.match(reg) ); // Array: ["<h1>", "h1"]
 ```
 [String#match](mdn:js/String/match) 只有在正则表达式中没有 `pattern:/.../g` 标记时才会返回组。
 
+<<<<<<< HEAD:5-regular-expressions/09-regexp-groups/article.md
 如果我们需要查找所有的匹配组，那么我们可以使用在 <info:regexp-methods> 中介绍过的 [RegExp#exec](mdn:js/RegExp/exec) 方法：
+=======
+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 `.matchAll` or `regexp.exec` as described in <info:regexp-methods>:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/09-regexp-groups/article.md
 
 ```js run
 let str = '<h1>Hello, world!</h1>';
@@ -73,13 +106,18 @@ let str = '<h1>Hello, world!</h1>';
 // 两组匹配：起始标签 <h1>和闭合标签</h1>
 let reg = /<(.*?)>/g;
 
-let match;
+let matches = Array.from( str.matchAll(reg) );
 
+<<<<<<< HEAD:5-regular-expressions/09-regexp-groups/article.md
 while (match = reg.exec(str)) {
   // 第一次显示匹配：<h1>,h1
   // 之后显示匹配：</h1>,/h1
   alert(match);
 }
+=======
+alert(matches[0]); //  Array: ["<h1>", "h1"]
+alert(matches[1]); //  Array: ["</h1>", "/h1"]
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/09-regexp-groups/article.md
 ```
 
 如此我们便得到了 `pattern:<(.*?)>` 的两个匹配项，他们中的每一个都包括完整的匹配和对应的捕获组。
@@ -145,13 +183,88 @@ alert( match[2] ); // c
 
 数组的长度依然是 `3`。但是因为捕获组 `pattern:(z)?` 没有对应项，所以结果为 `["ac", undefined, "c"]`。
 
+<<<<<<< HEAD:5-regular-expressions/09-regexp-groups/article.md
 ## 非捕获组 ?:
 
 某些时候，我们会希望使用括号来正确设置量词，但是并不希望其内容出现在结果数组中。
+=======
+## 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 the contents in results.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/09-regexp-groups/article.md
 
 你可以通过在开头加上 `pattern:?:` 从而在结果中排除该组。
 
+<<<<<<< HEAD:5-regular-expressions/09-regexp-groups/article.md
 例如，我们希望找到 `pattern:(go)+`，但是并不希望其内容（`go`）出现在单独的数组项中，那么我们可以这样写：`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)+`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/09-regexp-groups/article.md
 
 下面的例子中，只有名字『John』会作为一个独立项出现在 `results` 数组里：
 
@@ -167,3 +280,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 0000000000..4949237a31
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 0000000000..6dcdfe4065
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 0000000000..a7a934e4ae
--- /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 52%
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
index 8cb19b19f4..b4f4ed2ea9 100644
--- 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
@@ -1,14 +1,20 @@
 
 起始标签是 `pattern:\[(b|url|quote)\]`。
 
+<<<<<<< HEAD:5-regular-expressions/11-regexp-alternation/02-find-matching-bbtags/solution.md
 匹配字符串直到遇到结束标签 —— 模式 `pattern:[\s\S]*?` 匹配任意字符，包括换行和用于结束标记的反向引用。
 
 完整模式为：`pattern:\[(b|url|quote)\][\s\S]*?\[/\1\]`。
+=======
+Then to find everything till the closing tag -- let's use the pattern `pattern:.*?` with flag `s` to match any character including the newline and then add a backreference to the closing tag.
+
+The full pattern: `pattern:\[(b|url|quote)\].*?\[/\1\]`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/11-regexp-alternation/02-find-matching-bbtags/solution.md
 
 运行代码如下：
 
 ```js run
-let reg = /\[(b|url|quote)\][\s\S]*?\[\/\1\]/g;
+let reg = /\[(b|url|quote)\].*?\[\/\1\]/gs;
 
 let str = `
   [b]hello![/b]
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 93%
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
index 51ec2d7e6a..366c8837e4 100644
--- 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
@@ -32,7 +32,7 @@ BB-tags 可以嵌套。但标签不能自嵌套，比如：
 举例：
 
 ```js
-let reg = /your regexp/g;
+let reg = /your regexp/flags;
 
 let str = "..[url]http://google.com[/url]..";
 alert( str.match(reg) ); // [url]http://google.com[/url]
@@ -41,7 +41,7 @@ alert( str.match(reg) ); // [url]http://google.com[/url]
 如果标签嵌套，那么我们需要记录匹配的外层标签（如果希望继续查找匹配的标签内容的话）：
 
 ```js
-let reg = /your regexp/g;
+let reg = /your regexp/flags;
 
 let str = "..[url][b]http://google.com[/b][/url]..";
 alert( str.match(reg) ); // [url][b]http://google.com[/b][/url]
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 57%
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
index 1ed1428291..e691c28669 100644
--- 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
@@ -2,15 +2,25 @@
 
 构建一个正则表达式用于匹配双引号内的字符串 `subject:"..."`。
 
+<<<<<<< HEAD:5-regular-expressions/11-regexp-alternation/03-match-quoted-string/task.md
 最重要的部分是字符串应该支持转义，正如 JavaScript 字符串的行为一样。例如，引号可以插入为 `subject:\"`，换行符为 `subject:\n`，斜杠本身为 `subject:\\`。
+=======
+The strings should support escaping, the same way as JavaScript strings do. For instance, quotes can be inserted as `subject:\"` a newline as `subject:\n`, and the slash itself as `subject:\\`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/11-regexp-alternation/03-match-quoted-string/task.md
 
 ```js
 let str = "Just like \"here\".";
 ```
 
+<<<<<<< HEAD:5-regular-expressions/11-regexp-alternation/03-match-quoted-string/task.md
 对我们来说，重要的是转义的引号 `subject:\"` 不会结束字符串匹配。
 
 所以，我们应该匹配两个引号之间的内容，且忽略中间转义的引号。
+=======
+Please note, in particular, that an escaped quote `subject:\"` does not end a string.
+
+So we should search from one quote to the other ignoring escaped quotes on the way.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb: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 52%
rename from 5-regular-expressions/11-regexp-alternation/article.md
rename to 9-regular-expressions/11-regexp-alternation/article.md
index 8314a0d68c..968f4e05ab 100644
--- a/5-regular-expressions/11-regexp-alternation/article.md
+++ b/9-regular-expressions/11-regexp-alternation/article.md
@@ -20,34 +20,59 @@ alert( str.match(reg) ); // 'HTML', 'CSS', 'JavaScript'
 
 我们已知的一个相似符号 —— 方括号。就允许在许多字符中进行选择，例如 `pattern:gr[ae]y` 匹配 `match:gray` 或 `match:grey`。
 
+<<<<<<< HEAD:5-regular-expressions/11-regexp-alternation/article.md
 选择符号并非在字符级别生效，而是在表达式级别。正则表达式 `pattern:A|B|C` 意思是命中 `A`、`B` 或 `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`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/11-regexp-alternation/article.md
 
 例如：
 
+<<<<<<< HEAD:5-regular-expressions/11-regexp-alternation/article.md
 - `pattern:gr(a|e)y` 严格等同 `pattern:gr[ae]y`。
 - `pattern:gra|ey` 匹配 "gra" or "ey"。
+=======
+- `pattern:gr(a|e)y` means exactly the same as `pattern:gr[ae]y`.
+- `pattern:gra|ey` means `match:gra` or `match:ey`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/11-regexp-alternation/article.md
 
 我们通常用圆括号把模式中的选择部分括起来，像这样 `pattern:before(XXX|YYY)after`。
 
 ## 时间正则表达式
 
+<<<<<<< HEAD:5-regular-expressions/11-regexp-alternation/article.md
 在之前的章节中有个任务是构建用于查找形如 `hh:mm` 的时间字符串，例如 `12:00`。但是简单的 `pattern:\d\d:\d\d` 过于模糊。它同时匹配 `25:99`。
+=======
+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 (as 99 seconds match the pattern).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/11-regexp-alternation/article.md
 
 如何构建更优的正则表达式？
 
+<<<<<<< HEAD:5-regular-expressions/11-regexp-alternation/article.md
 我们可以应用到更多的严格匹配结果中：
 
 - 首个匹配数字必须是 `0` 或 `1`，同时其后还要跟随任一数字。
 - 或者是数字 `2` 之后跟随 `pattern:[0-3]`。
+=======
+We can apply more careful matching. First, the hours:
+
+- 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]`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/11-regexp-alternation/article.md
 
 构建正则表达式：`pattern:[01]\d|2[0-3]`。
 
+<<<<<<< HEAD:5-regular-expressions/11-regexp-alternation/article.md
 接着可以添加冒号和分钟的部分。
 
 分钟的部分必须在 `0` 到 `59` 区间，在正则表达式语言中含义为首个匹配数字 `pattern:[0-5]` 其后跟随任一数字 `\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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/11-regexp-alternation/article.md
 
 把他们拼接在一起形成最终的模式 `pattern:[01]\d|2[0-3]:[0-5]\d`。
 
+<<<<<<< HEAD:5-regular-expressions/11-regexp-alternation/article.md
 快大功告成了，但仍然存在一个问题。选择符 `|` 在 `pattern:[01]\d` 和 `pattern:2[0-3]:[0-5]\d` 之间。这是错误的，因为它只匹配符号左侧或右侧任一表达式。
 
 
@@ -60,6 +85,11 @@ alert("12".match(reg)); // 12 (matched [01]\d)
 这个错误相当明显，但也是初学正则表达式的常见错误。
 
 我们需要添加一个插入语用于匹配时钟：`[01]\d` 或 `2[0-3]`。
+=======
+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`.
+
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/11-regexp-alternation/article.md
 
 以下为正确版本：
 
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 89%
rename from 5-regular-expressions/12-regexp-anchors/article.md
rename to 9-regular-expressions/12-regexp-anchors/article.md
index 06623f9535..6286c5d481 100644
--- a/5-regular-expressions/12-regexp-anchors/article.md
+++ b/9-regular-expressions/12-regexp-anchors/article.md
@@ -18,7 +18,11 @@ alert( /^Mary/.test(str2) ); // false
 
 现在让我们匹配所有以一个 email 结尾的文本：
 
+<<<<<<< HEAD:5-regular-expressions/12-regexp-anchors/article.md
 为了去匹配一个 email，我们可以使用 `pattern:[-.\w]+@([\w-]+\.)+[\w-]{2,20}` 这个正则表达式，它不是完美的，但是大多数情况下都可以正常工作。
+=======
+To match an email, we can use a regexp `pattern:[-.\w]+@([\w-]+\.)+[\w-]{2,20}`.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/12-regexp-anchors/article.md
 
 为了匹配以 email 结尾的文本，让我们给这个正则表达式添加一个 `$` 吧：
 
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 0000000000..376d52d668
--- /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/9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md b/9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
new file mode 100644
index 0000000000..c53dfb75ad
--- /dev/null
+++ b/9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
@@ -0,0 +1,435 @@
+# 无限回溯问题
+
+有些正则表达式看起来简单，但会执行很长很长的时间，甚至会“挂起” JavaScript 引擎。
+
+绝大多数开发者迟早会遇到这种行为。
+
+典型的情况 —— 一个正则表达式有时候工作正常，但对于特定的字符串它会“挂起”占用 100% 的 CPU。
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+这甚至可能是一个漏洞。例如，如果 JavaScript 运行在服务器上，并且它使用正则表达式来处理用户数据，那么这样的输入可能会拒绝服务。笔者亲自看到并报告过这些漏洞，即使对于众所周知且广泛使用的程序也是如此。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+所以这个问题是绝对值得解决的。
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+## 实例
+=======
+## Introduction
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+计划将会是这样的：
+
+1. 首先我们观察问题是如何出现的。
+2. 然后我们简化场景并分析问题为什么会出现。
+3. 然后我们修复它。
+
+例如，让我们考虑在 HTML 中查找标签。
+
+我们想要查找所有的标签，有或者没有属性 —— 比如 `<a href="..." class="doc" ...>`。我们需要正则表达式可靠地工作，因为 HMTL 是来自网络的并可能会很混乱。
+
+特别的，我们需要匹配像 `<a test="<>" href="#">` —— 属性里有 `<` 和 `>` 的标签。这在 [HTML standard](https://html.spec.whatwg.org/multipage/syntax.html#syntax-attributes) 中是允许的。
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+现在我们可以看到像 `<[^>]+>` 这样简单的正则表达式不起作用，因为它停在了第一个 `>`，我们需要忽略属性里的 `<>`。
+=======
+A simple regexp like `pattern:<[^>]+>` doesn't work, because it stops at the first `>`, and we need to ignore `<>` if inside an attribute:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+```js run
+// 匹配没有抵达标签的末尾 —— 错误！
+alert( '<a test="<>" href="#">'.match(/<[^>]+>/) ); // <a test="<>
+```
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+我们需要整个标签。
+
+要正确处理这种情况我们需要一个更复杂的正则表达式。它将有 `<tag (key=value)*>` 这样的形式。
+
+在正则表达式语言中是 `<\w+(\s*\w+=(\w+|"[^"]*")\s*)*>`：
+
+1. `<\w+` —— 是标签的开始,
+2. `(\s*\w+=(\w+|"[^"]*")\s*)*` —— 是一个任意数量的 `word=value` 对，其中值可以是单词 `\w+` 或者一个带引号的字符串 `"[^"]*"`。
+
+这还不支持 HTML 语法的一些细节，例如在“单个”引号中的字符串，但它们可以以后添加，因此它们和现实生活有些接近。目前我们想要简单的正则表达式。
+
+让我们实际操作一下：
+=======
+To correctly handle such situations we need a more complex regular expression. It will have the form  `pattern:<tag (key=value)*>`.
+
+1. For the `tag` name: `pattern:\w+`,
+2. For the `key` name: `pattern:\w+`,
+3. And the `value`: 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 regexp is not perfect! It doesn't support all the details of HTML syntax, such as unquoted values, and there are other ways to improve, but let's not add complexity. It will demonstrate the problem for us.
+
+The regexp seems to work:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+```js run
+let reg = /<\w+(\s*\w+="[^"]*"\s*)*>/g;
+
+let str='...<a test="<>" href="#">... <b>...';
+
+alert( str.match(reg) ); // <a test="<>" href="#">, <b>
+```
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+很好，它生效了。它找到了长标签 `<a test="<>" href="#">` 和短标签 `<b>`。
+
+现在让我们看看问题。
+
+如果你运行下面的示例，它可能会挂起浏览器（或任何运行的 JavaScript 引擎）：
+=======
+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.
+
+## Infinite backtracking
+
+If you run our regexp on the input below, it may hang the browser (or another JavaScript host):
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+```js run
+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"`;
+
+*!*
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+// 查询会耗费很长很长的时间
+=======
+// The search will take a long, long time
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+alert( str.match(reg) );
+*/!*
+```
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+一些正则表达式引擎可以处理该搜索，但大多数都不行。
+
+这是怎么回事？为什么在这么小的字符串上，一个简单的正则表达式会“挂起” ？
+
+让我们通过删除标记和引用的字符串来简化场景。
+
+这里我们只查看属性：
+=======
+Some regexp engines can handle that search, but most of them can't.
+
+What's the matter? Why a simple regular expression "hangs" on such a small string?
+
+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*)*>`.
+
+Unfortunately, the regexp still hangs:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+```js run
+// 只查找用空格分隔的属性
+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`;
+
+*!*
+// 查询会耗费很长很长的时间
+alert( str.match(reg) );
+*/!*
+```
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+同样的问题仍然存在。
+
+在这里，我们结束问题的演示，并开始研究发生了什么以及它为什么会挂起。
+
+## 回溯
+=======
+Here we end the demo of the problem and start looking into what's going on, why it hangs and how to fix it.
+
+## Detailed example
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+为了使问题更简单，我们考虑一下 `(\d+)*$`。
+
+这个正则表达式也有同样的问题。在大多数正则表达式引擎中，搜索需要很长时间（小心 —— 会挂起）：
+
+```js run
+alert( '12345678901234567890123456789123456789z'.match(/(\d+)*$/) );
+```
+
+那么这个正则表达式有什么问题？
+
+首先，有人可能注意到这个正则表达式有一点奇怪。量词 `*` 看起来是多余的。如果我们需要一个数字，我们可以使用 `\d+$`。
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+实际上，正则表达式是人写的。但它缓慢的原因与我们上面看到的相同。所以让我们理解它，然后回到现实生活中的例子。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+在线路 `123456789z` 中搜索 `(\d+)*$` 期间发生了什么？
+
+1. 首先，regexp 引擎试图找到一个数字 `\d+`。默认情况下，加号 `+` 是贪婪的，所以它消耗所有数字：
+
+    ```
+    \d+.......
+    (123456789)z
+    ```
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+2. 然后它试图在括号周围应用星号 `(\d+)*`，但没有更多的数字，所以星号没有给出任何东西。
+
+    然后该模式具有字符串结束锚 `$`，并且在文本中我们有 `z`。
+=======
+2. Then it tries to apply the star quantifier, but there are no more digits, so it the star doesn't give anything.
+
+3. Then the pattern expects to see the string end `pattern:$`, and in the text we have `subject:z`, so there's no match:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+    ```
+               X
+    \d+........$
+    (123456789)z
+    ```
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+    没有匹配！
+3. 没有匹配，所以贪婪的量词 `+` 会减少重复次数（回溯）。
+
+    现在 `\d+` 就不是所有数字了，而是除最后一个之外的所有数字：
+=======
+4. As there's no match, the greedy quantifier `pattern:+` decreases the count of repetitions (backtracks).
+
+    Now `\d+` doesn't take all digits, but all except the last one:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+    ```
+    \d+.......
+    (12345678)9z
+    ```
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+4. 现在引擎尝试从新位置（`9`）继续搜索。
+
+    起始的 `(\d+)*` 可以被应用上 —— 它给出了数字 `9`：
+=======
+5. Now the engine tries to continue the search from the new position (`9`).
+
+    The star `pattern:(\d+)*` can be applied -- it gives the number `match:9`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+    ```
+
+    \d+.......\d+
+    (12345678)(9)z
+    ```
+
+    引擎再次尝试匹配 `$`，但失败了，因为遇到 `z`：
+
+    ```
+                 X
+    \d+.......\d+
+    (12345678)(9)z
+    ```
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+    没有匹配，因此引擎将继续回溯。
+5. 现在第一个数字 `\d+` 将会有 7 位数，字符串的其余部分 `89` 是第二个数字 `\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+`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+    ```
+                 X
+    \d+......\d+
+    (1234567)(89)z
+    ```
+
+    ...仍然无法匹配 `$`。
+
+    搜索引擎会再次回溯。回溯通常是这样工作的：只要可以最后一个贪心量词会减少重复次数。然后先前的贪心量词减少，依此类推。在我们的例子中，最后一个贪心量词是第二个 `\d+`，从 `89` 变为 `8`，星号匹配到 `9`：
+	
+    ```
+                   X
+    \d+......\d+\d+
+    (1234567)(8)(9)z
+    ```
+6. ...再次失败。第二个和第三个 `\d+` 回溯到最后，所以第一个量词缩短为匹配 `123456`，然后星号匹配剩余部分：
+
+    ```
+                 X
+    \d+.......\d+
+    (123456)(789)z
+    ```
+
+    再次失败。重复该过程：最后一个贪心量词释放一个字符（`9`）：
+
+    ```
+                   X
+    \d+.....\d+ \d+
+    (123456)(78)(9)z
+    ```
+7. ...然后继续。
+
+正则表达式引擎遍历了 `123456789` 子序列的所有组合。它们是有很多的，这就是为什么它会花费这么长时间。
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+一个聪明的家伙可能在这里会说：“回溯？让我们打开懒惰模式 —— 不再有回溯！”。
+
+让我们用 `\d+?` 代替 `\d+`，看它是否生效（小心，会引起浏览器挂起）
+=======
+What to do?
+
+Should we turn on the lazy mode?
+
+Unfortunately, it doesn't: if we replace `pattern:\d+` with `pattern:\d+?`, that still hangs:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+```js run
+// 非非非常慢
+alert( '12345678901234567890123456789123456789z'.match(/(\d+?)*$/) );
+```
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+不，它没有（生效）。
+
+惰性量词实际上是一样的，只是顺序相反。试想一下搜索引擎在这种情况下会怎么工作。
+=======
+Lazy quantifiers actually do the same, but in the reverse order.
+
+Just think about how the search engine would work in this case.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+有些正则表达式引擎具有复杂的内置检查来检测无限回溯或其他方法来解决它们，但是没有通用的解决方案。
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+在上面的例子中，当我们在字符串 `<a=b  a=b  a=b  a=b` 中查找 `<(\s*\w+=\w+\s*)*>` 时 —— 类似的情况发生了。
+
+字符串最后没有包含 `>`，所以匹配是不可能的，但正则表达式引擎不知道这些。搜索回溯尝试 `(\s*\w+=\w+\s*)` 的不同组合：
+=======
+## 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 doesn't know about it. The search backtracks trying different combinations of `pattern:(\s*\w+=\w+\s*)`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+```
+(a=b a=b a=b) (a=b)
+(a=b a=b) (a=b a=b)
+(a=b) (a=b a=b a=b)
+...
+```
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+## 如何修复？
+
+问题 —— 即便我们不需要它们，回溯也有很多变种。
+
+例如，在模式 `(\d+)*$` 中，我们（人类）可以轻易的看到 `(\d+)` 不需要回溯。
+
+减少 `\d+` 的计数对匹配没有帮助，这两者没有区别：
+=======
+As there are many combinations, it takes a lot of time.
+
+## How to fix?
+
+The backtracking checks many variants that are an obvious fail for a human.
+
+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+`:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+```
+\d+........
+(123456789)z
+
+\d+...\d+....
+(1234)(56789)z
+```
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+让我们回到更现实生活中的例子：`<(\s*\w+=\w+\s*)*>`。我们想要查找键值对 `name=value`（尽可能多）。这里没有必要回溯。
+
+换而言之，如果它找到很多 `name=value` 对然后找不到 `>`，那就没有必要减少重复次数。即使我们少匹配一对，它也不会给我们闭合的 `>`：
+=======
+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).
+
+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
+```
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+现代的正则表达式引擎支持所谓的“占有”量词。它们就像贪婪，但根本不回溯。很简单的，它们抓取尽可能多的东西，然后继续搜索。还有另一种叫做“原子组”的工具用来禁止括号内部的回溯。
+
+不幸的是，JavaScript 对这两项功能都不支持。
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+虽然我们可以使用前瞻来获得类似的效果。在文章[正则表达式: 使用前瞻模拟原子分组（和占有量词）](http://instanceof.me/post/52245507631/regex-emulate-atomic-grouping-with-lookahead)和[模拟原子组](http://blog.stevenlevithan.com/archives/mimic-atomic-groups)中更多关于占有量词和前瞻之间的关系。
+=======
+### Lookahead to the rescue
+
+We can forbid backtracking using lookahead.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+在没有回溯的前提下尽可能多重复使用的模式是：`(?=(a+))\1`。
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+换句话说，前瞻 `?=` 从当前位置查找最大 `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` (`pattern:\1` corresponds to the content of the second parentheses, that is `pattern:a+`).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+这里没有回溯，因为前瞻不会回溯。如果它检索了 5 次 `a+` 并且进一步匹配失败，那么它不会回到 4。
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+让我们修复本章开头的带有属性标签的正则表达式 `<\w+(\s*\w+=(\w+|"[^"]*")\s*)*>`。我们将使用前瞻来防止 `name=value` 对的回溯：
+=======
+```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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+```js run
+// 搜索 name=value 的正则表达式
+let attrReg = /(\s*\w+=(\w+|"[^"]*")\s*)/
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+// 在标签正则表达式中使用
+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');
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+let goodInput = '...<a test="<>" href="#">... <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( goodInput.match(fixedReg) ); // <a test="<>" href="#">, <b>
+alert( badInput.match(fixedReg) ); // null (no results, fast!)
+```
+
+<<<<<<< HEAD:5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+很好，它起作用了。我们找到一个长标签 `<a test="<>" href="#">` 和一个小标签 `<b>`，并且没有挂起引擎。
+=======
+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.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+
+请留意 `attrReg.source` 属性。`RegExp` 对象提供对其源字符串的访问。当我们想要将一个正则表达式插入另一个正则表达式时，这很方便。
diff --git a/5-regular-expressions/06-regexp-unicode/article.md b/9-regular-expressions/20-regexp-unicode/article.md
similarity index 58%
rename from 5-regular-expressions/06-regexp-unicode/article.md
rename to 9-regular-expressions/20-regexp-unicode/article.md
index 9403e9499b..86b5db9763 100644
--- a/5-regular-expressions/06-regexp-unicode/article.md
+++ b/9-regular-expressions/20-regexp-unicode/article.md
@@ -1,7 +1,11 @@
 # unicode 标记
 unicide 标记 `/.../u` 可以正确支持 UTF16 编码代理对。
 
+<<<<<<< HEAD:5-regular-expressions/06-regexp-unicode/article.md
 代理对在章节 <info:string> 已经做了解释。
+=======
+# Unicode: flag "u"
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/20-regexp-unicode/article.md
 
 让我们在这里简单回忆下它们。简而言之，普通的字符通常使用两个字节作为编码。这让我们最多只能表示 65536 个字符。但是在这个世界中要表示的字符比这个数量要多得多。
 
@@ -35,6 +39,7 @@ alert('𝒳'.length); // 2
 这会导致奇怪的结果，比如说，让我们尝试在字符串 `subject:𝒳` 中查找 `pattern:[𝒳𝒴]`。
 
 ```js run
+<<<<<<< HEAD:5-regular-expressions/06-regexp-unicode/article.md
 alert( '𝒳'.match(/[𝒳𝒴]/) ); // 奇怪的结果
 ```
 
@@ -45,23 +50,70 @@ alert( '𝒳'.match(/[𝒳𝒴]/) ); // 奇怪的结果
 换句话说，这种情况类似在 `'12'.match(/[1234]/)` 的查询中 —— 其结果会返回 `1`（相当于 `𝒳` 的左边一半）。
 
 使用 `/.../u` 标记可以修复这个问题。它可以在正则引擎中增加对引用对的支持，所以这样得到的结果就是对的。
+=======
+alert( '𝒳'.match(/[𝒳𝒴]/) ); // odd result (wrong match actually, "half-character")
+```
+
+The result is wrong, because by default the regexp engine does not understand surrogate pairs.
+
+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)`.
+
+We can list them like this:
+
+```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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/20-regexp-unicode/article.md
 
 ```js run
 alert( '𝒳'.match(/[𝒳𝒴]/u) ); // 𝒳
 ```
 
+<<<<<<< HEAD:5-regular-expressions/06-regexp-unicode/article.md
 如果我们忘记了这个标记，就可能会出现一个错误：
+=======
+Let's see one more example.
+
+If we forget the `u` flag and occasionally use surrogate pairs, then we can get an error:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/20-regexp-unicode/article.md
 
 ```js run
 '𝒳'.match(/[𝒳-𝒴]/); // SyntaxError: invalid range in character class
 ```
 
+<<<<<<< HEAD:5-regular-expressions/06-regexp-unicode/article.md
 在这里正则查询 `[𝒳-𝒴]` 被当作 `[12-34]`（在其中 `2` 是 `𝒳` 右边的部分，`3` 是 `𝒴` 中左边的部分），而在这两个 `2` 和 `3` 范围之间内的字符是不可接受的。
 
 使用下面的标记这个函数就可以正常工作：
+=======
+Normally, regexps understand `[a-z]` as a "range of characters with codes between codes of `a` and `z`.
+
+But without `u` flag, surrogate pairs are assumed to be a "pair of independent 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:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/20-regexp-unicode/article.md
 
 ```js run
 alert( '𝒴'.match(/[𝒳-𝒵]/u) ); // 𝒴
 ```
+<<<<<<< HEAD:5-regular-expressions/06-regexp-unicode/article.md
 
 最后，请注意，如果我们不处理代理对，那么这个标记对我们来说并没有任何作用。但是在现代世界中，我们经常会遇到这些 unicode 字符。
+=======
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb:9-regular-expressions/20-regexp-unicode/article.md
diff --git a/9-regular-expressions/21-regexp-unicode-properties/article.md b/9-regular-expressions/21-regexp-unicode-properties/article.md
index 453d41a0b4..4cf4fd612e 100644
--- a/9-regular-expressions/21-regexp-unicode-properties/article.md
+++ b/9-regular-expressions/21-regexp-unicode-properties/article.md
@@ -1,3 +1,4 @@
+<<<<<<< HEAD
 # Unicode 属性匹配（\p）
 
 JavaScript 中字符串使用的编码格式 Unicode 对于不同的字符（更严谨地说，码位）有大量的类别。这些类别描述了这个字符的“种类”和技术性细节。
@@ -41,30 +42,93 @@ JavaScript 中字符串使用的编码格式 Unicode 对于不同的字符（更
 
 ```js run
 let reg = /\p{Hex_Digit}{6}/u; // flag 'u' is required （注意 flag 'u' 是必须的）
+=======
+
+# Unicode character properties \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 required
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 alert("color: #123ABC".match(reg)); // 123ABC
 ```
 
+<<<<<<< HEAD
 还有有值的类别。如，Unicode "Script"（脚本，一种书写方式）可以表达西里尔字母、希腊文、阿拉伯语和中文等等。
 
 要对一个单一的书写系统进行搜索，就要另外提供 `Script=<value>`。如，要搜索西里尔字母，应使用 `\p{sc=Cyrillic}`，而对于汉字，应使用 `\p{sc=Han}`，等等。以下是使用这种特性的代码片段：
 
 ```js run
 let regexp = /\p{sc=Han}+/gu; // get chinese words （获得中文字符）
+=======
+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 characters in certain scripts ("alphabets"), 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
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 let str = `Hello Привет 你好 123_456`;
 
 alert( str.match(regexp) ); // 你好
 ```
 
+<<<<<<< HEAD
 ## 写对于所有语言都适用的 \w
 
 请给所有的语言写一个“全面的” `pattern:\w` 的正则表达式。这一问题在很多有针对 Unicode 优化的正则表达式特性的编程语言中都有标准解决方式，如 Perl。
+=======
+## Building multi-language \w
+
+The pattern `pattern:\w` means "wordly characters", but doesn't work for languages that use non-Latin alphabets, such as Cyrillic and others. It's just a shorthand for `[a-zA-Z0-9_]`, so `pattern:\w+` won't find any Chinese words etc.
+
+Let's make a "universal" regexp, that looks for wordly characters in any language. That's easy to do using Unicode properties:
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js
 /[\p{Alphabetic}\p{Mark}\p{Decimal_Number}\p{Connector_Punctuation}\p{Join_Control}]/u
 ```
 
+<<<<<<< HEAD
 请跟我一起对它进行分析。由于 `pattern:\w` 其实就是 `pattern:[a-zA-Z0-9_]`，
 
 所以这个字符集包含了：
@@ -76,6 +140,17 @@ alert( str.match(regexp) ); // 你好
 * `Join_Control` —— 用于将字连起形成连字（如在阿拉伯语中使用）的两个特殊的码位（hex 分别为 `200c` 和 `200d`）
 
 或者，如果换用缩写（[缩写列表](https://www.unicode.org/Public/UCD/latest/ucd/PropertyValueAliases.txt)）：
+=======
+Let's decipher. Just as `pattern:\w` is the same as `pattern:[a-zA-Z0-9_]`, we're making a set of our own, that 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)):
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ```js run
 let regexp = /([\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]+)/gu;
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 0000000000..57c7a0b1f7
--- /dev/null
+++ b/9-regular-expressions/22-regexp-sticky/article.md
@@ -0,0 +1,73 @@
+
+# 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 in them, and, generally, for text analysis: "What kind of entity is 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)
+
+So, we should try to match a couple of regular expressions, and make a decision what's at the given position.
+
+In JavaScript, how can we perform a search starting from a given position? Regular calls start searching from the text start.
+
+We'd like to avoid creating substrings, as this slows down the execution considerably.
+
+One option is to use `regexp.exec` with `regexp.lastIndex` property, but that's not what we need, as this would search the text starting from `lastIndex`, while we only need to text the match *exactly* at the given position.
+
+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 match. 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 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 test a regular expression 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/9-regular-expressions/index.md b/9-regular-expressions/index.md
new file mode 100644
index 0000000000..7499c584dd
--- /dev/null
+++ b/9-regular-expressions/index.md
@@ -0,0 +1,7 @@
+# Regular expressions
+
+Regular expressions is a powerful way of doing search and replace in strings.
+
+In JavaScript regular expressions are implemented using objects of a built-in `RegExp` class and integrated with strings.
+
+Please note that regular expressions vary between programming languages. In this tutorial we concentrate on JavaScript. Of course there's a lot in common, but they are a somewhat different in Perl, Ruby, PHP etc.
diff --git a/AUTHORING.md b/AUTHORING.md
new file mode 100644
index 0000000000..17516b583b
--- /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="/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/LICENSE.md b/LICENSE.md
index b616c0dc98..5f401833f2 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,6 +1,16 @@
 本教程阅读免费。
 
+<<<<<<< HEAD
 如果你想将本教程做其他用途，请获得本教程中文版负责人 [LeviDing](https://github.com/leviding)：imdingxuewen@gmail.com 和原版负责人 [Ilya Kantor](https://github.com/iliakan)：iliakan@javascript.ru 的许可。
+=======
+The tutorial is free to read.
+
+If you'd like to do something else with it, please get a permission from Ilya Kantor, iliakan@javascript.ru.
+
+As of now, we license the tutorial to almost everyone for free under the terms of an "open" CC-BY-NC-SA license. Just please be so kind to contact me.
+
+## Attribution-NonCommercial-ShareAlike license (CC-BY-NC-SA)
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 截至目前，我们根据“开放式” CC-BY-NC-SA 许可条款免费向几乎所有人授予教程许可。有问题敬请联系我。
 
diff --git a/README.md b/README.md
index 3f60f7ffc3..8ba6107021 100755
--- a/README.md
+++ b/README.md
@@ -1,11 +1,18 @@
+<<<<<<< HEAD
 # 现代 JavaScript 教程中文版
 
 这个仓库托管了现代 JavaScript 教程的中文版内容，发布于 [https://zh.javascript.info](https://zh.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).
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 <a href="https://coding.net/?utm_source=javascript-tutorial-zh&utm_medium=banner&utm_campaign=march2019" target="_blank"><img src="https://user-images.githubusercontent.com/26959437/56273145-c56aa000-612e-11e9-9137-a1388ef18cf2.png" width="300px;" target="_blank"/></a>
 
+<<<<<<< HEAD
 ## 翻译
 
 我们希望提供本教程的多语言版本。如果你感兴趣，那就快来和我们一起翻译吧。
@@ -35,6 +42,21 @@ If maintainers do not respond, or if you'd like to become a maintainer, write us
 Your name and the contribution size will appear in the "About project" page when the translation gets published.
 
 P.S. The full list of languages can be found at <https://javascript.info/translate>.
+=======
+We'd like to make the tutorial available in many languages. Please help us to translate.
+
+See <https://javascript.info/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>.
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
 
 ## Structure
 
@@ -151,6 +173,14 @@ The server and install instructions are at <https://github.com/javascript-tutori
 
 ---
 
+<<<<<<< HEAD
 💓  
 - Levi Ding [@leviding](https://github.com/leviding)
 - Ilya Kantor [@iliakan](https://github.com/iliakan)
+=======
+It's very easy to add something new.
+
+---
+💓  
+Ilya Kantor @iliakan
+>>>>>>> a0266c574c0ab8a0834dd38ed65e7e4ee27f9cdb
diff --git a/archive/01-hello-world/1-hello-alert/solution.md b/archive/01-hello-world/1-hello-alert/solution.md
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/archive/01-hello-world/1-hello-alert/solution.view/index.html b/archive/01-hello-world/1-hello-alert/solution.view/index.html
deleted file mode 100644
index 45e6744b3a..0000000000
--- a/archive/01-hello-world/1-hello-alert/solution.view/index.html
+++ /dev/null
@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<html>
-
-<body>
-
-  <script>
-    alert( "I'm JavaScript!" );
-  </script>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/archive/01-hello-world/1-hello-alert/task.md b/archive/01-hello-world/1-hello-alert/task.md
deleted file mode 100644
index afed6a91d3..0000000000
--- a/archive/01-hello-world/1-hello-alert/task.md
+++ /dev/null
@@ -1,12 +0,0 @@
-importance: 5
-
----
-
-# Show an alert
-
-Create a page that shows a message "I'm JavaScript!".
-
-Do it in a sandbox, or on your hard drive, doesn't matter, just ensure that it works.
-
-[demo src="solution"]
-
diff --git a/archive/01-hello-world/hello-world-render.png b/archive/01-hello-world/hello-world-render.png
deleted file mode 100644
index ffe810697c..0000000000
Binary files a/archive/01-hello-world/hello-world-render.png and /dev/null differ
diff --git a/archive/01-hello-world/hello-world-render@2x.png b/archive/01-hello-world/hello-world-render@2x.png
deleted file mode 100644
index c4411027ca..0000000000
Binary files a/archive/01-hello-world/hello-world-render@2x.png and /dev/null differ
diff --git a/archive/02-external-script/1-hello-alert-ext/alert.js b/archive/02-external-script/1-hello-alert-ext/alert.js
deleted file mode 100644
index 4de725971d..0000000000
--- a/archive/02-external-script/1-hello-alert-ext/alert.js
+++ /dev/null
@@ -1 +0,0 @@
-alert("I'm JavaScript!");
\ No newline at end of file
diff --git a/archive/02-external-script/1-hello-alert-ext/index.html b/archive/02-external-script/1-hello-alert-ext/index.html
deleted file mode 100644
index 10895f8fe2..0000000000
--- a/archive/02-external-script/1-hello-alert-ext/index.html
+++ /dev/null
@@ -1,10 +0,0 @@
-<!DOCTYPE html>
-<html>
-
-<body>
-
-  <script src="alert.js"></script>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/archive/02-external-script/1-hello-alert-ext/solution.md b/archive/02-external-script/1-hello-alert-ext/solution.md
deleted file mode 100644
index f42c41e6db..0000000000
--- a/archive/02-external-script/1-hello-alert-ext/solution.md
+++ /dev/null
@@ -1,8 +0,0 @@
-The HTML code:
-
-[html src="index.html"]
-
-For the file `alert.js` in the same folder:
-
-[js src="alert.js"]
-
diff --git a/archive/02-external-script/1-hello-alert-ext/task.md b/archive/02-external-script/1-hello-alert-ext/task.md
deleted file mode 100644
index fe38de403e..0000000000
--- a/archive/02-external-script/1-hello-alert-ext/task.md
+++ /dev/null
@@ -1,9 +0,0 @@
-importance: 5
-
----
-
-# Show an alert with an external script
-
-Take the solution of the previous task <info:task/hello-alert>. Modify it by extracting the script content into an external file `alert.js`, residing in the same folder.
-
-Open the page, ensures that the alert works.
diff --git a/archive/02-external-script/2-async-defer-first/solution.md b/archive/02-external-script/2-async-defer-first/solution.md
deleted file mode 100644
index 0513e5fc05..0000000000
--- a/archive/02-external-script/2-async-defer-first/solution.md
+++ /dev/null
@@ -1,5 +0,0 @@
-Answers:
-
-1. The first is `big.js`, that's a normal sequence for external `<script>` tags.
-2. The first is `small.js`, because `async` makes script behave independently of each other and the page. The first to loads runs first.
-3. The first is `big.js`, because "deferred" scripts keep relative execution order.
diff --git a/archive/02-external-script/2-async-defer-first/task.md b/archive/02-external-script/2-async-defer-first/task.md
deleted file mode 100644
index 90093a4cd3..0000000000
--- a/archive/02-external-script/2-async-defer-first/task.md
+++ /dev/null
@@ -1,29 +0,0 @@
-importance: 4
-
----
-
-# Which script executes first?
-
-In the questions below, there are two scripts: `small.js` and `big.js`.
-
-If we assume that `small.js` loads much faster compared to `big.js` -- which script executes first?
-
-```html
-<script src="big.js"></script>
-<script src="small.js"></script>
-```
-
-What if we add `async`?
-
-```html
-<script async src="big.js"></script>
-<script async src="small.js"></script>
-```
-
-What if we switch to `defer`?
-
-```html
-<script defer src="big.js"></script>
-<script defer src="small.js"></script>
-```
-
diff --git a/archive/02-external-script/banner.js b/archive/02-external-script/banner.js
deleted file mode 100644
index 6569ffd54e..0000000000
--- a/archive/02-external-script/banner.js
+++ /dev/null
@@ -1 +0,0 @@
-alert("Banner loaded!");
diff --git a/archive/06-events-and-timing-in-depth/article.md b/archive/06-events-and-timing-in-depth/article.md
deleted file mode 100644
index f706880325..0000000000
--- a/archive/06-events-and-timing-in-depth/article.md
+++ /dev/null
@@ -1,306 +0,0 @@
-
-# Sync and async events
-
-JavaScript is a single-threaded language: only one script may execute at a given moment of time.
-
-Other activities like rendering, downloading etc may be managed by separate threads. For instance, JavaScript may execute while the browser is downloading a file, that's normal. But it is impossible that two event handlers or two `setTimeout`-scheduled function execute simultaneously.
-
-There is a [Web Workers](http://www.w3.org/TR/workers) standard which defines the support for multiple JavaScript *workers* -- subprocesses that may execute in parallel with the main code, but their abilities are limited. In the browser workers don't have access to DOM, so again we come to a single "main" JavaScript thread.
-
-## Asynchronous events   
-
-Most events are asynchronous.
-
-When an asynchronous event occurs, it gets into the *Event queue*.
-
-The browser has inner loop, called *Event Loop*, which checks the queue and processes events, executes functions etc.
-
-For example, if the browser is busy processing your `onclick`, and another event happens in the background, it is appended to the queue. When the `onclick` handler is complete, the queue is checked and the script is executed.
-
-Calls scheduled by `setTimeout/setInterval` are also passed through the event queue, so that they wait until the JavaScript engine gets free.
-
-
-## Synchronous events   
-
-There are events which don't use the event queue. They are called *synchronous events* and work immediately even when inside other handlers.</b>
-
-
-### DOM mutation events are synchronous.   
-
-In the example below, the `onclick` handler changes an attribute of the link, which has a `DOMAttrModified(onpropertychange for IE)` listener.
-
-[summary]
-Synchronous mutation events are processed immediately during `onclick`.
-[/summary]
-
-Click the link to see:
-[html autorun height=auto]
-<a href="#">Click me!</a>
-
-<script>
-let a = document.body.children[0]
-
-a.onclick = function() {
-  alert('in onlick')
-  this.setAttribute('href', 'lala')
-  alert('out onclick')
-  return false
-}
-
-function onpropchange() {
-  alert('onpropchange')
-}
-
-if (a.addEventListener) { // FF, Opera
-  a.addEventListener('DOMAttrModified', onpropchange, false)
-}
-if (a.attachEvent) { // IE
-  a.attachEvent('onpropertychange', onpropchange)
-}
-</script>
-[/html]
-
-The `click` processing order:
-<ol>
-<li>`alert('in onclick')` works.</li>
-<li>The attribute is changed and the DOM mutation event is processed synchronously, immediately triggering `onchange`. It outputs `alert('onpropchange')`.</li>
-<li>The rest of `onclick` executes, leading to `alert('out onclick')`.</li>
-</ol>
-
-
-### Nested DOM events are synchronous.   
-
-[summary]
-There are methods which trigger an immediate event, like `elem.focus()`. These events are also processed in a synchronous manner.
-[/summary]
-
-Run the example below and click on the button. Notice that `onfocus`
-doesn't wait `onclick` to complete, it works immediately.
-
-[html autorun height=auto]
-<input type="button" value="click me">
-<input type="text">
-
-<script>
-  let button = document.body.children[0]
-  let text = document.body.children[1]
-
-  button.onclick = function() {
-    alert('in onclick')
-
-    text.focus()
-
-    alert('out onclick')
-  }
-
-  text.onfocus = function() {
-    alert('onfocus')
-    text.onfocus = null  //(*)
-  }
-</script>
-[/html]
-
-In the example above, the alert order is in <code>onclick-&gt;focus-&gt;out onclick</code>, that clearly demonstrates the synchronous behavior.
-
-[smart]
-The line labelled (*) is required, because `alert(message)` focuses on the message window. When it is disposed, the browser refocuses back.
-
-So without (*) the `focus` would be triggered one extra time after the alert.
-[/smart]
-
-[summary]
-Events are also processed immediately when triggered from JavaScript by `dispatchEvent/fireEvent`.
-[/summary]
-
-Usually event handlers are executed one by one. So we assume that one handler finishes before the other starts.
-
-**Synchronous events break this one-by-one rule, that may can cause side-effects.**
-
-For example, the `onfocus` handler may assume that `onclick` has completed the job.
-
-There are two ways to fix it:
-<ol>
-<li>Move `text.focus()` to the end of the `onclick` code.</li>
-<li>Wrap `text.focus()` into `setTimeout(.., 0)`:
-[js]
-button.onclick = function() {
-  alert(1)
-  setTimeout(function() { text.focus() }, 0)
-  alert(2)
-}
-[/js]
-</li>
-</ol>
-
-The concrete way is chosen according to your architecture.
-
-
-## JavaScript execution and rendering   
-
-[summary]In most browsers, rendering and JavaScript use single event queue. It means that while JavaScript is running, no rendering occurs.[/summary]
-
-Check it on the demo below. **When you press `run`, the browser may halt for some time**, because it changes `div.style.backgroundColor` from #A00000 to #FFFFFF.
-
-In most browsers, you see nothing until the script finishes, or until the browser pauses it with a message that 'a script is running too long'.
-
-The exception is Opera.
-
-[html run]
-<div style="width:200px;height:50px;background-color:#A00000"></div>
-
-<input type="button" onclick="run()" value="run()">
-
-<script>
-function run() {
-  let div = document.getElementsByTagName('div')[0]
-  for(let i=0xA00000;i<0xFFFFFF;i++) {
-    div.style.backgroundColor = '#'+i.toString(16)
-  }
-}
-</script>
-[/html]
-
-In Opera, you may notice `div` is redrawn. Not every change causes a repaint, probably because of Opera internal scheduling. That's because event queues for rendering and JavaScript are different in this browser.
-
-In other browsers the repaint is postponed until the JavaScript finishes.
-
-Again, the implementation may be different, but generally **the nodes are marked as "dirty" (want to be recalculated and redrawn), and repaint is queued**. Or, the browser may just look for dirty nodes after every script and process them.
-
-[smart header="Immediate reflow"]
-The browser contains many optimizations to speedup rendering and painting. Generally, it tries to postpone them until the script is finished, but some actions require nodes to be rerendered immediately.
-
-For example:
-[js]
-elem.innerHTML = 'new content'
-alert(elem.offsetHeight)  // <-- rerenders elem to get offsetHeight
-[/js]
-
-In the case above, the browser has to perform relayouting to get the height.
-But it doesn't have to repaint `elem` on the screen.
-
-Sometimes other dependant nodes may get involved into calculations. This process is called *reflow* and may consume lots of resources if script causes it often.
-
-Surely, there's much more to talk about rendering. It will be covered by a separate article [todo].
-[/smart]
-
-
-## Modal and synchronous calls   
-
-[summary]Modal and synchronous calls like `alert` pause the JavaScript thread.
-
-That causes related activities to freeze.
-[/summary]
-
-The example below demonstrates it.
-
-<ol>
-<li>Press "Run". The `setInterval`-based animation will start and and `alert` button will appear.</li>
-<li>Press the button, note that the animation stops.</li>
-</ol>
-
-<input type="button" onclick="alert('Hello!')" value="alert('Hello!')  [ main window ]">
-[html run height=60]
-<div style="height:20px;width:0px;background-color:green"></div>
-<script>
-let timer = setInterval(function() {
-  let style = document.getElementsByTagName('div')[0].style
-  style.width = (parseInt(style.width)+2)%400 + 'px'
-}, 30)
-
-</script>
-<input type="button" onclick="alert('Hello!')" value="alert('Hello!')  [ iframe ]">
-<input type="button" onclick="clearInterval(timer)" value="clearInterval(timer)">
-[/html]
-
-When you press `alert('Hello!')`, the `alert` blocks JavaScript execution and blocks the whole UI thread. That's how `alert`, `confirm` and `prompt` work. And there is only one thread. So, **`setTimeout/setInterval` can't execute while the thread is blocked.**
-
-
-### Opera: `iframes` exception.   
-
-[summary]Usually, `iframes` run in the same thread with the page. [/summary]
-
-But there is an exception called Opera. **Run the example above in Opera** and press alert in the <u>main window</u>. The iframe animation will continue!
-That's because the example is actually running in an iframe.
-
-Other browsers use single thread for whole tab, so the iframe animation is paused there.
-
-
-
-## Script taking too long and heavy jobs   
-
-JavaScript can be heavy.
-
-In this case, the browser may hangup for a moment or come with a warning "Script is taking too long".
-
-We'd want to evade that. It can be done by split the job into parts which get scheduled after each other.
-
-Then there is a "free time" for the browser to respond between parts. It is can render and react on other events. Both the visitor and the browser are happy.
-
-The background color in the example below is changed once per tick. So the browser has the time to render it, and there are no hangups. Changes are applied incrementally.
-
-Press the run button on the example to start.
-[html run]
-<div style="width:200px;height:50px;background-color:#100"></div>
-
-<input type="button" onclick="run()" value="run()">
-<input type="button" onclick="stop()" value="stop()">
-
-<script>
-let timer
-
-function run() {
-  let div = document.getElementsByTagName('div')[0]
-  let i=0x100000
-
-  function func() {
-    timer = setTimeout(func, 0)
-    div.style.backgroundColor = '#'+i.toString(16)
-    if (i++ == 0xFFFFFF) stop()
-  }
-
-*!*
-  timer = setTimeout(func, 0)
-*/!*
-}
-
-function stop() {
-  clearInterval(timer)
-}
-</script>
-[/html]
-
-The internal order:
-<ol>
-<li>`setTimeout` appends the `func` call to the event queue.</li>
-<li>The new call is scheduled on the next tick.</li>
-<li>The func executes and changes the `div` which appends a repaint request to the queue.</li>
-<li>The function finishes. The browser takes the next event from the queue which is repaint and executes it. Then it waits the next tick to execute one more `func` call (see step 2).</li>
-<li>Repeated until `stop()`</li>
-</ol>
-
-A delay may be increased from 0 to 100 ms, depending on your needs. The longer delay leads to less CPU load.
-
-[smart header="Evade the 'script is running for too long' warning"]
-As an important side-effect, splitting the long job into parts which are executed by `setTimeout` helps to fix browser hangups and evade warnings.
-
-For example, modern syntax highlighters employ such technique. When a visitor opens a large text, they highlight a part of it then call something like `setTimeout(highlightNext, 50)` which highlights the next part etc.
-
-It would hangup otherwise, because the syntax highlighting takes time.
-[/smart]
-
-
-
-## Summary   
-
-Most browsers use single thread for UI and JavaScript, which is blocked by synchronous calls. So, JavaScript execution blocks the rendering.
-
-Events are processed asynchronously with the exception of DOM events.
-
-The `setTimeout(..,0)` trick is very useful. It allows to:
-<ul>
-<li>Let the browser render current changes.</li>
-<li>Evade the "script is running too long" warning.</li>
-<li>Change the execution flow.</li>
-</ul>
-
-Opera is special in many places when it comes to timeouts and threading.
diff --git a/archive/2-eval-calculator-errors/solution.md b/archive/2-eval-calculator-errors/solution.md
deleted file mode 100644
index c564d3ee19..0000000000
--- a/archive/2-eval-calculator-errors/solution.md
+++ /dev/null
@@ -1,34 +0,0 @@
-Вычислить любое выражение нам поможет `eval`:
-
-```js run
-alert( eval("2+2") ); // 4
-```
-
-Считываем выражение в цикле `while(true)`. Если при вычислении возникает ошибка -- ловим её в `try..catch`.
-
-Ошибкой считается, в том числе, получение `NaN` из `eval`, хотя при этом исключение не возникает. Можно бросить своё исключение в этом случае.
-
-Код решения:
-
-```js run demo
-let expr, res;
-
-while (true) {
-  expr = prompt("Введите выражение?", '2-');
-  if (expr == null) break;
-
-  try {
-    res = eval(expr);
-    if (isNaN(res)) {
-      throw new Error("Результат неопределён");
-    }
-
-    break;
-  } catch (e) {
-    alert( "Ошибка: " + e.message + ", повторите ввод" );
-  }
-}
-
-alert( res );
-```
-
diff --git a/archive/2-eval-calculator-errors/task.md b/archive/2-eval-calculator-errors/task.md
deleted file mode 100644
index b317d52ea1..0000000000
--- a/archive/2-eval-calculator-errors/task.md
+++ /dev/null
@@ -1,14 +0,0 @@
-importance: 5
-
----
-
-#  Eval-калькулятор с ошибками [todo: NO EVAL YET]
-
-Напишите интерфейс, который принимает математическое выражение (в `prompt`) и результат его вычисления через `eval`.
-
-**При ошибке нужно выводить сообщение и просить переввести выражение**.
-
-Ошибкой считается не только некорректное выражение, такое как `2+`, но и выражение, возвращающее `NaN`, например `0/0`.
-
-[demo]
-
diff --git a/archive/2-events-and-timing-depth/article.md b/archive/2-events-and-timing-depth/article.md
deleted file mode 100644
index 3254326fa1..0000000000
--- a/archive/2-events-and-timing-depth/article.md
+++ /dev/null
@@ -1,170 +0,0 @@
-# Порядок обработки событий
-
-События могут возникать не только по очереди, но и "пачкой" по много сразу. Возможно и такое, что во время обработки одного события возникают другие, например пока выполнялся код для `onclick` -- посетитель нажал кнопку на клавиатуре (событие `keydown`).
-
-Здесь мы разберём, как браузер обычно работает с одновременно возникающими событиями и какие есть исключения из общего правила.
-
-## Главный поток
-
-В каждом окне выполняется только один *главный* поток, который занимается выполнением JavaScript, отрисовкой и работой с DOM.
-
-Он выполняет команды последовательно, может делать только одно дело одновременно и блокируется при выводе модальных окон, таких как `alert`.
-
-```smart header="Дополнительные потоки тоже есть"
-Есть и другие, служебные потоки, например, для сетевых коммуникаций.
-
-Поэтому скачивание файлов может продолжаться пока главный поток ждёт реакции на `alert`. Но управлять служебными потоками мы не можем.
-```
-
-```smart header="Web Workers"
-Существует спецификация <a href="http://www.w3.org/TR/workers/">Web Workers</a>, которая позволяет запускать дополнительные JavaScript-процессы(workers).
-
-Они могут обмениваться сообщениями с главным процессом, но у них свои переменные, и работают они также сами по себе.
-
-Такие дополнительные процессы не имеют доступа к DOM, поэтому они полезны, преимущественно, при вычислениях, чтобы загрузить несколько ядер/процессоров одновременно.
-```
-
-## Очередь событий
-
-Произошло одновременно несколько событий или во время работы одного случилось другое -- как главному потоку обработать это?
-
-Если главный поток прямо сейчас занят, то он не может срочно выйти из середины одной функции и прыгнуть в другую. А потом третью. Отладка при этом могла бы превратиться в кошмар, потому что пришлось бы разбираться с совместным состоянием нескольких функций сразу.
-
-Поэтому используется альтернативный подход.
-
-**Когда происходит событие, оно попадает в очередь.**
-
-Внутри браузера непрерывно работает "главный внутренний цикл", который следит за состоянием очереди и обрабатывает события, запускает соответствующие обработчики и т.п.
-
-**Иногда события добавляются в очередь сразу пачкой.**
-
-Например, при клике на элементе генерируется несколько событий:
-
-1. Сначала `mousedown` -- нажата кнопка мыши.
-2. Затем `mouseup` -- кнопка мыши отпущена и, так как это было над одним элементом, то дополнительно генерируется `click` (два события сразу).
-
-````online
-В действии:
-
-```html autorun height=150 no-beautify
-<textarea rows="8" cols="40" id="area">Кликни меня
-</textarea>
-
-<script>
-  area.onmousedown = function(e) { this.value += "mousedown\n"; this.scrollTop = this.scrollHeight; };
-  area.onmouseup = function(e) { this.value += "mouseup\n"; this.scrollTop = this.scrollHeight; };
-  area.onclick = function(e) { this.value += "click\n"; this.scrollTop = this.scrollHeight; };
-</script>
-```
-````
-
-Таким образом, при нажатии кнопки мыши в очередь попадёт событие `mousedown`, а при отпускании -- сразу два события: `mouseup` и `click`. Браузер обработает их строго одно за другим: `mousedown` -> `mouseup` -> `click`.
-
-При этом каждое событие из очереди обрабатывается полностью отдельно от других.
-
-## Вложенные (синхронные) события
-
-Обычно возникающие события "становятся в очередь".
-
-Но в тех случаях, когда событие инициируется не посетителем, а кодом, то оно, как правило, обрабатывается синхронно, то есть прямо сейчас.
-
-Рассмотрим в качестве примера событие `onfocus`.
-
-### Пример: событие onfocus
-
-Когда посетитель фокусируется на элементе, возникает событие `onfocus`. Обычно оно происходит, когда посетитель кликает на поле ввода, например:
-
-```html run height=80 autorun
-<p>При фокусе на поле оно изменит значение.</p>
-<input type="text" onfocus="this.value = 'Фокус!'" value="Кликни меня">
-```
-
-Но ту же фокусировку можно вызвать и явно, вызовом метода `elem.focus()`:
-
-```html run
-<input type="text" id="elem" onfocus="this.value = 'Фокус!'">
-
-<script>
-*!*
-  // сфокусируется на input и вызовет обработчик onfocus
-  elem.focus();
-*/!*
-</script>
-```
-
-В главе <info:focus-blur> мы познакомимся с этим событием подробнее, а пока -- нажмите на кнопку в примере ниже.
-
-При этом обработчик `onclick` вызовет метод `focus()` на текстовом поле `text`. Код обработчика `onfocus`, который при этом запустится, сработает синхронно, прямо сейчас, до завершения `onclick`.
-
-```html autorun height=80 no-beautify
-<input type="button" id="button" value="Нажми меня">
-<input type="text" id="text" size="60">
-
-<script>
-
-  button.onclick = function() {
-    text.value += ' ->в onclick ';
-
-    text.focus(); // вызов инициирует событие onfocus
-
-    text.value += ' из onclick-> ';
-  };
-
-  text.onfocus = function() {
-    text.value += ' !focus! ';
-  };
-</script>
-```
-
-При клике на кнопке в примере выше будет видно, что управление вошло в `onclick`, затем перешло в `onfocus`, затем вышло из `onclick`.
-
-```warn header="Исключение в IE"
-Так ведут себя все браузеры, кроме IE.
-
-В нём событие `onfocus` -- всегда асинхронное, так что будет сначала полностью обработан клик, а потом -- фокус. В остальных -- фокус вызовется посередине клика. Попробуйте кликнуть в IE и в другом браузере, чтобы увидеть разницу.
-```
-
-## Делаем события асинхронными через setTimeout(...,0)
-
-А что, если мы хотим, чтобы *сначала* закончилась обработка `onclick`, а потом уже произошла обработка `onfocus` и связанные с ней действия?
-
-Можно добиться и этого.
-
-Один вариант -- просто переместить строку `text.focus()` вниз кода обработчика `onclick`.
-
-Если это неудобно, можно запланировать `text.focus()` чуть позже через `setTimeout(..., 0)`, вот так
-
-```html autorun height=80
-<input type="button" id="button" value="Нажми меня">
-<input type="text" id="text" size="60">
-
-<script>
-  button.onclick = function() {
-    text.value += ' ->в onclick ';
-
-*!*
-    setTimeout(function() {
-      text.focus(); // сработает после onclick
-    }, 0);
-*/!*
-
-    text.value += ' из onclick-> ';
-  };
-
-  text.onfocus = function() {
-    text.value += ' !focus! ';
-  };
-</script>
-```
-
-Такой вызов обеспечит фокусировку через минимальный "тик" таймера, по стандарту равный 4 мс. Обычно такая задержка не играет роли, а необходимую асинхронность мы получили.
-
-## Итого
-
-- JavaScript выполняется в едином потоке. Современные браузеры позволяют порождать подпроцессы <a href="http://www.w3.org/TR/workers/">Web Workers</a>, они выполняются параллельно и могут отправлять/принимать сообщения, но не имеют доступа к DOM.
-- Обычно события становятся в очередь и обрабатываются в порядке поступления, асинхронно, независимо друг от друга.
-- Синхронными являются вложенные события,  инициированные из кода.
-- Чтобы сделать событие гарантированно асинхронным, используется вызов через `setTimeout(func, 0)`.
-
-Отложенный вызов через `setTimeout(func, 0)` используется не только в событиях, а вообще -- всегда, когда мы хотим, чтобы некая функция `func` сработала после того, как текущий скрипт завершится.
-
diff --git a/archive/4-random-from-array/solution.md b/archive/4-random-from-array/solution.md
deleted file mode 100644
index c07a93bc42..0000000000
--- a/archive/4-random-from-array/solution.md
+++ /dev/null
@@ -1,12 +0,0 @@
-We need to generate a random integer value from `0` to `arr.length-1`, and then take the element with that index.
-
-Here we go:
-
-```js run
-let arr = ["Apple", "Orange", "Pear", "Lemon"];
-
-let rand = Math.floor(Math.random() * arr.length);
-
-alert( arr[rand] );
-```
-
diff --git a/archive/4-random-from-array/task.md b/archive/4-random-from-array/task.md
deleted file mode 100644
index c40a10c19d..0000000000
--- a/archive/4-random-from-array/task.md
+++ /dev/null
@@ -1,11 +0,0 @@
-importance: 3
-
----
-
-# A random array value
-
-Write the code to `alert` a random value from the array:
-
-```js
-let arr = ["Apple", "Orange", "Pear", "Lemon"];
-```
diff --git a/archive/5-drag-and-drop-objects/article.md b/archive/5-drag-and-drop-objects/article.md
deleted file mode 100644
index 3b8f331363..0000000000
--- a/archive/5-drag-and-drop-objects/article.md
+++ /dev/null
@@ -1,512 +0,0 @@
-# Мышь: Drag'n'Drop более глубоко
-
-В [предыдущей статье](/drag-and-drop) мы рассмотрели основы Drag'n'Drop. Здесь мы разберём дополнительные "тонкие места" и приёмы реализации, которые возникают на практике.
-
-Почти все javascript-библиотеки реализуют Drag'n'Drop так, как написано (хотя бывает что и менее эффективно).
-
-Зная, что и как, вы сможете легко написать свой код переноса или поправить, адаптировать существующую библиотеку под себя.
-
-Этот материал не строго обязателен для изучения, он специфичен именно для Drag'n'Drop.
-
-## Документ
-
-Как пример задачи -- возьмём документ с иконками браузера ("объекты переноса"), которые можно переносить в компьютер ("цель переноса"):
-
-- Элементы, которые можно переносить (иконки браузеров), помечены классом `draggable`.
-- Элементы, на которые можно положить (компьютер), имеют класс `droppable`.
-
-```html
-<img src="chrome.png" class="*!*draggable*/!*">
-<img src="firefox.png" class="*!*draggable*/!*">
-<img src="ie.png" class="*!*draggable*/!*">
-<img src="opera.png" class="*!*draggable*/!*">
-<img src="safari.png" class="*!*draggable*/!*">
-
-<p>Браузер переносить сюда:</p>
-
-<img src="computer.gif" class="*!*droppable*/!*">
-```
-
-Работающий пример с переносом:
-
-[iframe border=1 src="dragDemo" height=280 link edit]
-
-Далее мы рассмотрим, как делается фреймворк для таких переносов, а в перспективе -- и для более сложных.
-
-Требования:
-
-- Поддержка большого количества элементов без "тормозов".
-- Продвинутые возможности по анимации переноса.
-- Удобная обработка успешного и неудачного переноса.
-
-## Начало переноса
-
-Чтобы начать перенос элемента, мы должны отловить нажатие левой кнопки мыши на нём. Для этого используем событие `mousedown`... И, конечно, делегирование.
-
-Переносимых элементов может быть много. В нашем документе-примере это всего лишь несколько иконок, но если мы хотим переносить элементы списка или дерева, то их может быть 100 штук и более.
-
-Поэтому повесим обработчик `mousedown` на контейнер, который содержит переносимые элементы, и будем определять нужный элемент поиском ближайшего `draggable` вверх по иерархии от `event.target`.
-
-В качестве контейнера здесь будем брать `document`, хотя это может быть и любой элемент.
-
-Найденный `draggable`-элемент сохраним в свойстве `dragObject.elem` и начнём двигать.
-
-Код обработчика `mousedown`:
-
-```js
-let dragObject = {};
-
-document.onmousedown = function(e) {
-
-  if (e.which != 1) { // если клик правой кнопкой мыши
-    return; // то он не запускает перенос
-  }
-
-  let elem = e.target.closest('.draggable');
-
-  if (!elem) return; // не нашли, клик вне draggable-объекта
-
-  // запомнить переносимый объект
-  dragObject.elem = elem;
-
-  // запомнить координаты, с которых начат перенос объекта
-  dragObject.downX = e.pageX;
-  dragObject.downY = e.pageY;
-}
-```
-
-```warn header="Не начинаем перенос по `mousedown`"
-Ранее мы по `mousedown` начинали перенос.
-
-Но на самом деле нажатие на элемент вовсе не означает, что его собираются куда-то двигать. Возможно, на нём просто кликают.
-
-Это важное различие. Снимать элемент со своего места и куда-то двигать нужно только при переносе.
-
-Чтобы отличить перенос от клика, в том числе -- от клика, который сопровождается нечаянным перемещением на пару пикселей (рука дрогнула), мы будем запоминать в `dragObject`, какой элемент (`elem`) и где (`downX/downY`) был зажат, а начало переноса будем инициировать из `mousemove`, если он передвинут хотя бы на несколько пикселей.
-```
-
-## Перенос элемента
-
-Первой задачей обработчика `mousemove` является инициировать начало переноса, если элемент передвинули в зажатом состоянии.
-
-Ну а второй задачей -- отображать его перенос при каждом передвижении мыши.
-
-Схематично, обработчик будет иметь такой вид:
-
-```js
-document.onmousemove = function(e) {
-  if (!dragObject.elem) return; // элемент не зажат
-
-  if (!dragObject.avatar) { // элемент нажат, но пока не начали его двигать
-    ...начать перенос, присвоить dragObject.avatar = переносимый элемент
-  }
-
-  ...отобразить перенос элемента...
-}
-```
-
-Здесь мы видим новое свойство `dragObject.avatar`. При начале переноса "аватар" делается из элемента и сохраняется в свойство `dragObject.avatar`.
-
-**"Аватар" -- это DOM-элемент, который перемещается по экрану.**
-
-Почему бы не перемещать по экрану сам `draggable`-элемент? Зачем, вообще, нужен аватар?
-
-Дело в том, что иногда сам элемент передвигать неудобно, например потому, что он слишком большой. А удобно создать некоторое визуальное представление элемента, и его уже переносить. Аватар дает такую возможность.
-
-А в простейшем случае аватаром можно будет сделать сам элемент, и это не повлечёт дополнительных расходов.
-
-### Визуальное перемещение аватара
-
-Для того, чтобы отобразить перенос аватара, достаточно поставить ему `position: absolute` и менять координаты `left/top`.
-
-Для использования абсолютных координат относительно документа, аватар должен быть прямым потомком `BODY`.
-
-Следующий код готовит аватар к переносу:
-
-```js
-// в начале переноса:
-if (avatar.parentNode != document.body) {
-  document.body.appendChild(avatar); // переместить в BODY, если надо
-}
-avatar.style.zIndex = 9999; // сделать, чтобы элемент был над другими
-avatar.style.position = 'absolute';
-```
-
-... А затем его можно двигать:
-
-```js
-// при каждом движении мыши
-
-avatar.style.left = новая координата + 'px';
-avatar.style.top = новая координата + 'px';
-```
-
-Как вычислять новые координаты `left/top` при переносе?
-
-Чтобы элемент сохранял свою позицию под курсором, необходимо при нажатии запомнить его изначальный сдвиг относительно курсора, и сохранять его при переносе.
-
-![](shiftx.png)
-
-Этот сдвиг по горизонтали обозначен `shiftX` на рисунке выше. Аналогично, есть `shiftY`. Они вычисляются как расстояние между курсором и левой/верхней границей элемента при `mousedown`. Детали вычислений описаны в главе <info:drag-and-drop>.
-
-Таким образом, при `mousemove` мы будем назначать элементу координаты курсора с учетом сдвига `shiftX/shiftY`:
-
-```js
-avatar.style.left = e.pageX - shiftX + 'px';
-avatar.style.top = e.pageY - shiftY + 'px';
-```
-
-## Полный код mousemove
-
-Код `mousemove`, решающий задачу начала переноса и позиционирования аватара:
-
-```js
-document.onmousemove = function(e) {
-  if (!dragObject.elem) return; // элемент не зажат
-
-  if ( !dragObject.avatar ) { // если перенос не начат...
-
-    // посчитать дистанцию, на которую переместился курсор мыши
-    let moveX = e.pageX - dragObject.downX;
-    let moveY = e.pageY - dragObject.downY;
-    if ( Math.abs(moveX) < 3 && Math.abs(moveY) < 3 ) {
-      return; // ничего не делать, мышь не передвинулась достаточно далеко
-    }
-
-    *!*dragObject.avatar = createAvatar(e)*/!*; // захватить элемент
-    if (!dragObject.avatar) {
-      dragObject = {}; // аватар создать не удалось, отмена переноса
-      return; // возможно, нельзя захватить за эту часть элемента
-    }
-
-    // аватар создан успешно
-    // создать вспомогательные свойства shiftX/shiftY
-    let coords = getCoords(dragObject.avatar);
-    dragObject.shiftX = dragObject.downX - coords.left;
-    dragObject.shiftY = dragObject.downY - coords.top;
-
-    *!*startDrag(e)*/!*; // отобразить начало переноса
-  }
-
-  // отобразить перенос объекта при каждом движении мыши
-  dragObject.avatar.style.left = e.pageX - dragObject.shiftX + 'px';
-  dragObject.avatar.style.top = e.pageY - dragObject.shiftY + 'px';
-
-  return false;
-}
-```
-
-Здесь используются две функции для начала переноса: `createAvatar(e)` и `startDrag(e)`.
-
-Функция `createAvatar(e)` создает аватар. В нашем случае в качестве аватара берется сам `draggable` элемент. После создания аватара в него записывается функция `avatar.rollback`, которая задает поведение при отмене переноса.
-
-Как правило, отмена переноса влечет за собой разрушение аватара, если это был клон, или возвращение его на прежнее место, если это сам элемент.
-
-В нашем случае для отмены переноса нужно запомнить старую позицию элемента и его родителя.
-
-```js
-function createAvatar(e) {
-
-  // запомнить старые свойства, чтобы вернуться к ним при отмене переноса
-  let avatar = dragObject.elem;
-  let old = {
-    parent: avatar.parentNode,
-    nextSibling: avatar.nextSibling,
-    position: avatar.position || '',
-    left: avatar.left || '',
-    top: avatar.top || '',
-    zIndex: avatar.zIndex || ''
-  };
-
-  // функция для отмены переноса
-  avatar.rollback = function() {
-    old.parent.insertBefore(avatar, old.nextSibling);
-    avatar.style.position = old.position;
-    avatar.style.left = old.left;
-    avatar.style.top = old.top;
-    avatar.style.zIndex = old.zIndex
-  };
-
-  return avatar;
-}
-```
-
-Функция `startDrag(e)`, которую вызывает `mousemove`, если видит, что элемент в "зажатом" состоянии перенесли достаточно далеко, инициирует начало переноса и позиционирует аватар на странице:
-
-```js
-function startDrag(e) {
-  let avatar = dragObject.avatar;
-
-  document.body.appendChild(avatar);
-  avatar.style.zIndex = 9999;
-  avatar.style.position = 'absolute';
-}
-```
-
-## Окончание переноса
-
-Окончание переноса происходит по событию `mouseup`.
-
-Его обработчик можно поставить на аватаре, т.к. аватар всегда под курсором и `mouseup` происходит на нем. Но для универсальности и большей гибкости (вдруг мы захотим перемещать аватар *рядом* с курсором?) поставим его, как и остальные, на `document`.
-
-Задача обработчика `mouseup`:
-
-1. Обработать успешный перенос, если он идет (существует аватар)
-2. Очистить данные `dragObject`.
-
-Это дает нам следующий код:
-
-```js
-document.onmouseup = function(e) {
-  // (1) обработать перенос, если он идет
-  if (dragObject.avatar) {
-    *!*finishDrag(e)*/!*;
-  }
-
-  // в конце mouseup перенос либо завершился, либо даже не начинался
-  // (2) в любом случае очистим "состояние переноса" dragObject
-  dragObject = {};
-}
-```
-
-Для завершения переноса в функции `finishDrag(e)` нам нужно понять, на каком элементе мы находимся, и если над `droppable` -- обработать перенос, а нет -- откатиться:
-
-```js
-function finishDrag(e) {
-  let dropElem = *!*findDroppable(e)*/!*;
-
-  if (dropElem) {
-    ... успешный перенос ...
-  } else {
-    ... отмена переноса ...
-  }
-}
-```
-
-### Определяем элемент под курсором
-
-Чтобы понять, над каким элементом мы остановились -- используем метод [document.elementFromPoint(clientX, clientY)](https://developer.mozilla.org/en/DOM/document.elementFromPoint), который мы обсуждали в разделе [координаты](info:coordinates#elementFromPoint). Этот метод получает координаты *относительно окна* и возвращает самый глубокий элемент, который там находится.
-
-Функция `findDroppable(event)`, описанная ниже, использует его и находит самый глубокий элемент с атрибутом `droppable` под курсором мыши:
-
-```js
-// возвратит ближайший droppable или null
-*!*
-// это предварительный вариант findDroppable, исправлен ниже!
-*/!*
-function findDroppable(event) {
-
-  // взять элемент на данных координатах
-  let elem = document.elementFromPoint(event.clientX, event.clientY);
-
-  // найти ближайший сверху droppable
-  return elem.closest('.droppable');
-}
-```
-
-Обратите внимание -- для `elementFromPoint` нужны координаты относительно окна `clientX/clientY`, а не `pageX/pageY`.
-
-Вариант выше -- предварительный. Он не будет работать. Если попробовать применить эту функцию, будет все время возвращать один и тот же элемент! А именно -- *текущий переносимый*. Почему так?
-
-...Дело в том, что в процессе переноса под мышкой находится именно аватар. При начале переноса ему даже `z-index` ставится большой, чтобы он был поверх всех остальных.
-
-**Аватар перекрывает остальные элементы. Поэтому функция `document.elementFromPoint()` увидит на текущих координатах именно его.**
-
-Чтобы это изменить, нужно либо поправить код переноса, чтобы аватар двигался *рядом* с курсором мыши, либо дать аватару стиль `pointer-events:none` (кроме IE10-), либо:
-
-1. Спрятать аватар.
-2. Вызывать `elementFromPoint`.
-3. Показать аватар.
-
-Напишем функцию `findDroppable(event)`, которая это делает:
-
-```js
-function findDroppable(event) {
-  // спрячем переносимый элемент
-  dragObject.avatar.hidden = true;
-
-  // получить самый вложенный элемент под курсором мыши
-  let elem = document.elementFromPoint(event.clientX, event.clientY);
-
-  // показать переносимый элемент обратно
-  dragObject.avatar.hidden = false;
-
-  if (elem == null) {
-    // такое возможно, если курсор мыши "вылетел" за границу окна
-    return null;
-  }
-
-  return elem.closest('.droppable');
-}
-```
-
-## DragManager
-
-Из фрагментов кода, разобранных выше, можно собрать мини-фреймворк.
-
-Объект `DragManager` будет запоминать текущий переносимый объект и отслеживать его перенос.
-
-Для его создания используем не обычный синтаксис `{...}`, а вызов `new function`. Это позволит прямо при создании объявить дополнительные переменные и функции в замыкании, которыми могут пользоваться методы объекта, а также назначить обработчики:
-
-```js no-beautify
-let DragManager = new function() {
-
-  let dragObject = {};
-
-  let self = this; // для доступа к себе из обработчиков
-
-  function onMouseDown(e) { ... }
-  function onMouseMove(e) { ... }
-  function onMouseUp(e) { ... }
-
-  document.onmousedown = onMouseDown;
-  document.onmousemove = onMouseMove;
-  document.onmouseup = onMouseUp;
-
-  this.onDragEnd = function(dragObject, dropElem) { };
-  this.onDragCancel = function(dragObject) { };
-}
-```
-
-Всю работу будут выполнять обработчики `onMouse*`, которые оформлены как локальные функции. В данном случае они ставятся на `document` через `on...`, но это легко поменять на `addEventListener`.
-
-Код функции `onMouse*` мы подробно рассмотрели ранее, но вы сможете увидеть их в полном примере ниже.
-
-Внутренний объект `dragObject` будет содержать информацию об объекте переноса.
-
-У него будут следующие свойства, которые также разобраны выше:
-
-`elem`
-: Текущий зажатый мышью объект, если есть (ставится в `mousedown`).
-
-`avatar`
-: Элемент-аватар, который передвигается по странице.
-
-`downX/downY`
-: Координаты, на которых был клик `mousedown`
-
-`shiftX/shiftY`
-: Относительный сдвиг курсора от угла элемента, вспомогательное свойство вычисляется в начале переноса.
-
-Задачей `DragManager` является общее управление переносом. Что же касается действий при его окончании -- их должен назначить внешний код, который использует `DragManager`.
-
-Можно сделать это через вспомогательные методы `onDrag*`, которые устанавливаются внешним кодом и затем вызываются фреймворком. Разработчик, подключив `DragManager`, описывает в этих методах, что делать при завершении или отмене переноса. Конечно же, можно заменить методы `onDrag*` на генерацию "своих" событий.
-
-С использованием `DragManager` пример, с которого начиналась эта глава -- перенос иконок браузеров в компьютер, реализуется совсем просто:
-
-```js no-beautify
-DragManager.onDragEnd = function(dragObject, dropElem) {
-
-  // скрыть/удалить переносимый объект
-  dragObject.elem.hidden = true;
-
-  // успешный перенос, показать улыбку классом computer-smile
-  dropElem.className = 'computer computer-smile';
-
-  // убрать улыбку через 0.2 сек
-  setTimeout(function() {
-    dropElem.classList.remove('computer-smile');
-  }, 200);
-};
-
-DragManager.onDragCancel = function(dragObject) {
-  // откат переноса
-  dragObject.avatar.rollback();
-};
-```
-
-Полный пример с кодом:
-
-[codetabs src="dragDemo" height=280]
-
-## Расширения
-
-Существует масса возможных применений Drag'n'Drop. Здесь мы не будем реализовывать их все, поскольку не стоит цель создать фреймворк-монстр.
-
-Однако, мы рассмотрим их, чтобы, при необходимости, легко было написать то, что нужно.
-
-### Захватывать элемент можно только за "ручку"
-
-Часто бывает, что перенос должен быть инициирован только при захвате за определённую зону элемента. К примеру, модальное окно можно "взять", только захватив его за заголовок.
-
-Для этого достаточно добавить необходимую проверку, к примеру, в функцию `createAvatar` или перед её запуском.
-
-Если `mousedown` был внутри элемента, помеченного, к примеру, классом `draghandle`, то начинаем перенос, иначе -- нет.
-
-### Проверка прав на droppable
-
-Бывает и так, что не на любое место в `droppable` можно положить элемент.
-
-Например: в админке есть дерево всех объектов сайта: статей, разделов, посетителей и т.п.
-
-- В этом дереве есть узлы различных типов: "статьи", "разделы" и "пользователи".
-- Все узлы являются переносимыми объектами.
-- Узел "статья" (draggable) можно переносить в "раздел" (droppable), а узел "пользователи" -- нельзя. Но и то и другое можно поместить в "корзину".
-
-Здесь решение: "можно или нет" переносить или нельзя зависит от "типа" переносимого объекта.
-
-Есть и более сложные варианты, когда решение зависит от конкретного места в `droppable`, над которым посетитель отпустил кнопку мыши. К примеру, переносить в верхнюю часть можно, а в нижнюю -- нет.
-
-Эта задача решается добавлением проверки в `findDroppable(e)`. Эта функция знает и об аватаре и о событии, включая координаты. При попытке положить в "неправильное" место функция `findDroppable(e)` должна возвращать `null`.
-
-Однако, на практике бывают ситуации, когда решение "прямо сейчас" принять невозможно. Например, нужно сделать запрос на сервер: "А разрешено ли текущему посетителю производить такую операцию?"
-
-Как при этом должен вести себя интерфейс? Можно, конечно сделать, чтобы элемент после отпускания кнопки мыши "завис" над `droppable`, ожидая ответа. Однако, такое решение неудобно в реализации и странновато выглядит для посетителя.
-
-Как правило, применяют "оптимистичный" алгоритм, по которому мы считаем, что перенос обычно успешен, но при необходимости можем отменить его.
-
-При нём посетитель кладет объект туда, куда он хочет, а затем, в коде `onDragEnd`:
-
-1. Визуально обрабатывается завершение переноса, как будто все ок.
-2. Производится асинхронный запрос к серверу, содержащий информацию о переносе.
-3. Сервер обрабатывает перенос и возвращает ответ, все ли в порядке.
-4. Если нет -- выводится ошибка и возвращается `avatar.rollback()`. Аватар в этом случае должен предусматривать возможность отката после успешного завершения.
-
-Процесс общения с сервером сопровождается индикацией загрузки и, при необходимости, блокировкой новых операций переноса до получения подтверждения.
-
-### Подсветка текущего droppable
-
-Удобно, когда пользователь во время переноса наглядно видит, куда он сейчас положит draggable. Например, текущий droppable (или его часть) подсвечиваются.
-
-Для этого в `DragManager` можно добавить дополнительные методы интеграции с внешним кодом:
-
-- `onDragEnter` -- будет вызываться при заходе на `droppable`, из `onMouseMove`.
-- `onDragMove` -- при каждом передвижении внутри `droppable`, из `onMouseMove`.
-- `onDragLeave` -- при выходе с `droppable`, из `onMouseMove` и `onMouseUp`.
-
-Возможен более сложный вариант, когда нужно поддерживать не только перенос *в элемент*, но и перенос *между элементами*, например вставку одной статьи между двумя другими.
-
-Для этого код, который обрабатывает перенос, может "делить на части" droppable, к примеру, в отношении 25% - 50% - 25%, и смотреть:
-
-- Если перенос в верхнюю четверть, то это -- "над".
-- Если перенос в середину, то это "внутрь".
-- Если перенос в нижнюю четверть, то это -- "под".
-
-Текущий `droppable` и позиция относительно него при этом могут помечаться подсветкой и жирной чертой над/под, если требуется.
-
-Пример индикации из Firefox:
-![](between.png)
-
-### Анимация отмены переноса
-
-Отмену переноса и возврат аватара на место можно красиво анимировать.
-
-Один из частых вариантов -- скольжение объекта обратно к исходному месту, откуда его взяли. Для этого достаточно поправить `avatar.rollback()`.
-
-## Итого
-
-Уточнённый алгоритм Drag'n'Drop:
-
-1. При `mousedown` запомнить координаты нажатия.
-2. При `mousemove` инициировать перенос, как только зажатый элемент передвинули на 3 пикселя или больше. Сообщить во внешний код вызовом `onDragStart`. При этом:
-<ol>
-3. Создать аватар, если можно начать перенос элемента `draggable` с данной позиции курсора.
-4. Переместить аватар по экрану, установив его новую позицию из `e.pageX/pageY` с учетом изначального сдвига элемента относительно курсора.
-5. Сообщить во внешний код о текущем `droppable` под курсором и позиции над ним вызовами `onDragEnter`, `onDragMove`, `onDragLeave`.
-6. При `mouseup` обработать завершение переноса. Элемент под аватаром получить по координатам, предварительно спрятав аватар. Сообщить во внешний код вызовом `onDragEnd`.
-
-Получившаяся реализация Drag'n'Drop проста, эффективна, изящна.
-
-Её очень легко поменять или адаптировать под "особые" потребности.
-
-ООП-вариант фреймворка находится в статье <info:drag-and-drop-plus>.
diff --git a/archive/5-drag-and-drop-objects/between.png b/archive/5-drag-and-drop-objects/between.png
deleted file mode 100644
index 4001dff049..0000000000
Binary files a/archive/5-drag-and-drop-objects/between.png and /dev/null differ
diff --git a/archive/5-drag-and-drop-objects/dragDemo.view/DragManager.js b/archive/5-drag-and-drop-objects/dragDemo.view/DragManager.js
deleted file mode 100644
index 24a208db35..0000000000
--- a/archive/5-drag-and-drop-objects/dragDemo.view/DragManager.js
+++ /dev/null
@@ -1,157 +0,0 @@
-let DragManager = new function() {
-
-  /**
-   * составной объект для хранения информации о переносе:
-   * {
-   *   elem - элемент, на котором была зажата мышь
-   *   avatar - аватар
-   *   downX/downY - координаты, на которых был mousedown
-   *   shiftX/shiftY - относительный сдвиг курсора от угла элемента
-   * }
-   */
-  let dragObject = {};
-
-  let self = this;
-
-  function onMouseDown(e) {
-
-    if (e.which != 1) return;
-
-    let elem = e.target.closest('.draggable');
-    if (!elem) return;
-
-    dragObject.elem = elem;
-
-    // запомним, что элемент нажат на текущих координатах pageX/pageY
-    dragObject.downX = e.pageX;
-    dragObject.downY = e.pageY;
-
-    return false;
-  }
-
-  function onMouseMove(e) {
-    if (!dragObject.elem) return; // элемент не зажат
-
-    if (!dragObject.avatar) { // если перенос не начат...
-      let moveX = e.pageX - dragObject.downX;
-      let moveY = e.pageY - dragObject.downY;
-
-      // если мышь передвинулась в нажатом состоянии недостаточно далеко
-      if (Math.abs(moveX) < 3 && Math.abs(moveY) < 3) {
-        return;
-      }
-
-      // начинаем перенос
-      dragObject.avatar = createAvatar(e); // создать аватар
-      if (!dragObject.avatar) { // отмена переноса, нельзя "захватить" за эту часть элемента
-        dragObject = {};
-        return;
-      }
-
-      // аватар создан успешно
-      // создать вспомогательные свойства shiftX/shiftY
-      let coords = getCoords(dragObject.avatar);
-      dragObject.shiftX = dragObject.downX - coords.left;
-      dragObject.shiftY = dragObject.downY - coords.top;
-
-      startDrag(e); // отобразить начало переноса
-    }
-
-    // отобразить перенос объекта при каждом движении мыши
-    dragObject.avatar.style.left = e.pageX - dragObject.shiftX + 'px';
-    dragObject.avatar.style.top = e.pageY - dragObject.shiftY + 'px';
-
-    return false;
-  }
-
-  function onMouseUp(e) {
-    if (dragObject.avatar) { // если перенос идет
-      finishDrag(e);
-    }
-
-    // перенос либо не начинался, либо завершился
-    // в любом случае очистим "состояние переноса" dragObject
-    dragObject = {};
-  }
-
-  function finishDrag(e) {
-    let dropElem = findDroppable(e);
-
-    if (!dropElem) {
-      self.onDragCancel(dragObject);
-    } else {
-      self.onDragEnd(dragObject, dropElem);
-    }
-  }
-
-  function createAvatar(e) {
-
-    // запомнить старые свойства, чтобы вернуться к ним при отмене переноса
-    let avatar = dragObject.elem;
-    let old = {
-      parent: avatar.parentNode,
-      nextSibling: avatar.nextSibling,
-      position: avatar.position || '',
-      left: avatar.left || '',
-      top: avatar.top || '',
-      zIndex: avatar.zIndex || ''
-    };
-
-    // функция для отмены переноса
-    avatar.rollback = function() {
-      old.parent.insertBefore(avatar, old.nextSibling);
-      avatar.style.position = old.position;
-      avatar.style.left = old.left;
-      avatar.style.top = old.top;
-      avatar.style.zIndex = old.zIndex
-    };
-
-    return avatar;
-  }
-
-  function startDrag(e) {
-    let avatar = dragObject.avatar;
-
-    // инициировать начало переноса
-    document.body.appendChild(avatar);
-    avatar.style.zIndex = 9999;
-    avatar.style.position = 'absolute';
-  }
-
-  function findDroppable(event) {
-    // спрячем переносимый элемент
-    dragObject.avatar.hidden = true;
-
-    // получить самый вложенный элемент под курсором мыши
-    let elem = document.elementFromPoint(event.clientX, event.clientY);
-
-    // показать переносимый элемент обратно
-    dragObject.avatar.hidden = false;
-
-    if (elem == null) {
-      // такое возможно, если курсор мыши "вылетел" за границу окна
-      return null;
-    }
-
-    return elem.closest('.droppable');
-  }
-
-  document.onmousemove = onMouseMove;
-  document.onmouseup = onMouseUp;
-  document.onmousedown = onMouseDown;
-
-  this.onDragEnd = function(dragObject, dropElem) {};
-  this.onDragCancel = function(dragObject) {};
-
-};
-
-
-function getCoords(elem) { // кроме IE8-
-  let box = elem.getBoundingClientRect();
-
-  return {
-    top: box.top + pageYOffset,
-    left: box.left + pageXOffset
-  };
-
-}
\ No newline at end of file
diff --git a/archive/5-drag-and-drop-objects/dragDemo.view/dragDemo.css b/archive/5-drag-and-drop-objects/dragDemo.view/dragDemo.css
deleted file mode 100644
index d9cf2ac68b..0000000000
--- a/archive/5-drag-and-drop-objects/dragDemo.view/dragDemo.css
+++ /dev/null
@@ -1,15 +0,0 @@
-.computer {
-  width: 93px;
-  height: 98px;
-  background: url(https://js.cx/clipart/computer.gif) no-repeat;
-  padding: 5px;
-  font-style: italic;
-}
-
-.computer-smile {
-  background: url(https://js.cx/clipart/computer-smile.gif) no-repeat;
-}
-
-.draggable {
-  cursor: pointer;
-}
\ No newline at end of file
diff --git a/archive/5-drag-and-drop-objects/dragDemo.view/index.html b/archive/5-drag-and-drop-objects/dragDemo.view/index.html
deleted file mode 100644
index cb4fc01b24..0000000000
--- a/archive/5-drag-and-drop-objects/dragDemo.view/index.html
+++ /dev/null
@@ -1,41 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-
-<head>
-  <meta charset="UTF-8">
-  <script src="https://cdn.polyfill.io/v1/polyfill.js?features=Element.prototype.closest"></script>
-  <script src="DragManager.js"></script>
-  <link rel="stylesheet" href="dragDemo.css">
-  <script>
-    DragManager.onDragCancel = function(dragObject) {
-      dragObject.avatar.rollback();
-    };
-
-    DragManager.onDragEnd = function(dragObject, dropElem) {
-      dragObject.elem.style.display = 'none';
-      dropElem.classList.add('computer-smile');
-      setTimeout(function() {
-        dropElem.classList.remove('computer-smile');
-      }, 200);
-    };
-  </script>
-</head>
-
-<body>
-
-  <div style="height:64px">
-    <img src="https://js.cx/browsers/chrome.svg" class="draggable">
-    <img src="https://js.cx/browsers/firefox.svg" class="draggable">
-    <img src="https://js.cx/browsers/ie.svg" class="draggable">
-    <img src="https://js.cx/browsers/opera.svg" class="draggable">
-    <img src="https://js.cx/browsers/safari.svg" class="draggable">
-  </div>
-
-  <p>Браузер переносить сюда:</p>
-
-  <div class="computer droppable">
-  </div>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/archive/5-drag-and-drop-objects/shiftx.png b/archive/5-drag-and-drop-objects/shiftx.png
deleted file mode 100644
index 52d49dd466..0000000000
Binary files a/archive/5-drag-and-drop-objects/shiftx.png and /dev/null differ
diff --git a/archive/backticks.md b/archive/backticks.md
deleted file mode 100644
index 1f1dd5cdb7..0000000000
--- a/archive/backticks.md
+++ /dev/null
@@ -1,51 +0,0 @@
-
-Backticks allow to specify a "template function" before the first backtick. 
-
-The syntax is: 
-```js
-let str = func`my string`;
-```
-
-The function `func` is automatically called and receives the array of string pieces split by `${...}` embeds and the list of embedded `${...}` values.
-
-It's better to see the example:
-
-```js run
-function love(s, v1, v2) {
-  alert( s[0] ); // Hello:
-  alert( s[1] ); //  and 
-  alert( s[2] ); // !
-
-  alert( v1 ); // Ilya
-  alert( v2 ); // Julia
-
-  alert( s.raw[0] ); // Hello:\n
-
-  return v1 + ' ♥ ' + v2;
-}
-
-let mom = "Julia";
-let dad = "Ilya";
-
-//              s[0]    | v1 |  s[1] | v2 | s[2]
-let str = love`Hello:\n ${mom}  and  ${dad}!`;
-
-alert(str); // 'Julia ♥ Ilya'
-```
-
-The string inside <code>love&#96;string&#96;</code> is split into pieces by embeds. The result is passed to `love`:
-
-- The first parameter `s` stores the pieces, here `s = ["Hello:\n ", " and ", "!"]`.
-- The special proeprty `s.raw` contains unparsed values, the special characters are not processes.
-- Then follow the values of embeds: `v1 = mom`, `v2 = data`.
-
-Templating functions allow to 
-
-
-
-
-- The first parameter `strings` is a
-
-In the example above, `love` is the name for the function. It is called with an array 
-
-
diff --git a/archive/commend.md b/archive/commend.md
deleted file mode 100644
index acc2c27ee0..0000000000
--- a/archive/commend.md
+++ /dev/null
@@ -1,22 +0,0 @@
-### Don't hesitate to comment
-
-Please, don't hesitate to comment.
-
-Comments increase the overall code footprint, but that's not a problem at all, because there are many tools which minify the code before publishing to production server. They remove comments, so they do not appear in the working scripts.
-
-The code clarity is what we should hunt for. And comments can really help to make it easier to understand.
-
-There are various types of comments, answering different questions:
-
-- What the code does?
-- Why the code is written like that?
-- Which counter-intuitive or implicit connections it has with other parts of the program?
-
-Further in the tutorial we'll make more notes about how to write the code better, easier to read and maintain. We'll also talk more about comments.
-
-```smart header="The good code is inherently readable and self-commenting"
-Please note that the first type of comments ("what the code does") should be used to describe a "high-level" action, like the overall architecture, a function or a chunk of code. It's purpose is to give an overview, so a reader doesn't need to delve into the code and figure out.
-
-Novice programmers sometimes tend to elaborate too much. Please don't. The good code is inherently readable. No need to describe what few lines do. Unless it's something hard to grasp, and *then* it's worth to consider rewriting the code at the first place rather than commenting it.
-```
-
diff --git a/archive/descriptors.md b/archive/descriptors.md
deleted file mode 100644
index 14f1100911..0000000000
--- a/archive/descriptors.md
+++ /dev/null
@@ -1,37 +0,0 @@
-
-
-## Property descriptors
-
-An object property is actually a more complex and tunable thing than just a "key-value" mapping.
-
-There are two kinds of properties. 
-
-The first is *data properties*.
-
-They assiciate a key with the attributes:
-
-- **`value`** -- the value of the property.
-- **`writable`** -- if `true`, can be changed, otherwise it's read-only.
-- **`enumerable`** -- if `true`, then listed in loops, otherwise not listed.
-- **`configurable`** -- if `true`, the property can be deleted and these attributes can be modified, otherwise not.
-
-All properties that we've seen yet were data properties.
-
-By default when a property is created, all attributes are `true`.
-
-We can get the the information about an existing property using [Object.getOwnPropertyDescriptor](mdn:js/Object/getOwnPropertyDescriptor):
-
-
-```js run
-let user = {
-  name: "John"
-};
-
-let descriptor = Object.getOwnPropertyDescriptor(user, 'name');
-
-alert( descriptor.value ); // John
-alert( descriptor.writable ); // true
-alert( descriptor.enumerable ); // true
-alert( descriptor.configurable ); // true
-```
-
diff --git a/archive/nfe.md b/archive/nfe.md
deleted file mode 100644
index 7f7e2044b4..0000000000
--- a/archive/nfe.md
+++ /dev/null
@@ -1,140 +0,0 @@
-
-## Named Function Expression
-
-Named Function Expression or, shortly, NFE, is a term a Function Expression that has a name.
-
-For instance, let's take an ordinary Function Expression:
-
-```js
-let sayHi = function(who) {
-  alert(`Hello, ${who}`);
-};
-```
-
-...And add a name to it:
-
-```js
-let sayHi = function *!*func*/!*(who) {
-  alert(`Hello, ${who}`);
-};
-```
-
-What's the role of that additional `"func"` name?
-
-First let's note, that we're still having a Function Expression. Adding the name `"func"` after `function` did not make it a Function Declaration, because it is still created as a part of an assignment expression.
-
-Adding such a name also did not break anything. 
-
-The function is still available as `sayHi()`:
-
-```js
-//+ run
-let sayHi = function *!*func*/!*(who) {
-  alert(`Hello, ${who}`);
-};
-
-sayHi("John"); // Hello, John
-```
-
-There are two special things about the name `func`:
-<ol>
-<li>It allows to reference the function from inside itself.</li>
-<li>It is not visible outside of the function.</li>
-</ol>
-
-For instance, the function `sayHi` below re-calls itself with `"Guest"` if no `who` is provided:
-
-```js
-//+ run
-let sayHi = function *!*func*/!*(who) {
-  if (who) {
-    alert(`Hello, ${who}`);
-  } else {
-*!*
-    func("Guest"); // use func to re-call itself
-*/!* 
-  }
-};
-
-sayHi(); // Hello, Guest
-
-// But this won't work: 
-func(); // Error, func is not defined (not visible outside of the function)
-```
-
-Later we'll see more cases when a function wants to re-call itself with modified parameters.
-
-So, why won't we use `sayHi` for the nested call?
-
-Actually, in most cases we can:
-
-```js
-let sayHi = function(who) {
-  if (who) {
-    alert(`Hello, ${who}`);
-  } else {
-*!*
-    sayHi("Guest");
-*/!* 
-  }
-};
-```
-
-The problem with the latter code is that the value of `sayHi` may change. The function may go to another variable:
-
-```js
-//+ run
-let sayHi = function *!*func*/!*(who) {
-  if (who) {
-    alert(`Hello, ${who}`);
-  } else {
-*!*
-    func("Guest"); // (*)
-*/!* 
-  }
-};
-
-let welcome = sayHi;
-sayHi = null;
-
-welcome(); // Hello, Guest (still works under different name)
-```
-
-Using `func` in the line `(*)` *guarantees* that this exactly function will be called. Using `sayHi` there 
-
-
-...But the name `func` is not visible outside of the function:
-
-```js
-//+ run
-let sayHi = function *!*func*/!*(who) {
-  // ...
-};
-
-*!*
-func(); // Error: func is not defined
-*/!*
-```
-
-Named Function Expressions are used in rare cases when:
-<ul>
-<li>The function needs to reference itself from inside. For instance, call itself with another arguments.</li>
-<li>The function travels between variables.</li>
-</ul>
-
-The code below demonstrates both conditions:
-
-```js
-//+ run
-let sayHi = function *!*func*/!*(name) {
-  if (name) {
-    alert(`Hello, ${name}!`)
-  } else {
-    func("Guest");
-  }
-};
-
-welcome(); // Works
-```
-
-
diff --git a/archive/promise/async-then.js b/archive/promise/async-then.js
deleted file mode 100644
index 87150473de..0000000000
--- a/archive/promise/async-then.js
+++ /dev/null
@@ -1,60 +0,0 @@
-
-````smart header="Handlers are always asynchronous, like `setTimeout(...,0)`"
-Handlers assigned by `.then/catch` are always asynchronous. But if the promise is settled they run as soon as possible, similar to `setTimeout(...,0)`.
-
-Here's the example to demonstrate that:
-
-```js run
-// the promise is immediately resolved with "done!"
-let promise = new Promise(resolve => resolve("done!"));
-
-// alert runs asynchronously, like if it were wrapped in setTimeout(..., 0);
-promise.then(alert); // (2)
-
-alert('code end'); // (1)
-```
-
-We'll first see "code end" `(1)`, and then "done!" `(2)`.
-
-Like if we had this instead of `(2)`:
-```js
-promise.then(result => setTimeout(() => alert(result), 0));
-```
-
-The inner mechanics is like this:
-- Promise handlers form a queue.
-- When the current code is complete, the queue shifts and the next handler is executed.
-````
-
-````smart header="Functions resolve/reject accept at most one argument"
-Functions `resolve/reject` accept only one argument.
-
-We can call them without any arguments too, that's the same as passing `undefined`:
-
-```js run
-let promise = new Promise(resolve => resolve());
-
-promise.then(alert); // undefined
-```
-
-...But if we pass many arguments: `resolve(1, 2, 3)`, then all arguments after the first one are ignored.
-The idea is that a promise may have only one result (or an error). Use objects and destructuring if you need to pass many values, like this:
-
-```js run
-let promise = new Promise(function(resolve, reject) {
-  let name = "John";
-  let age = 25;
-
-  resolve({name, age}); // "pack" the values in an object
-});
-
-// destructuring
-promise.then(function({name, age}) {
-  // here we have name and age variables as if the promise had two results
-  alert(`${name} ${age}`); // John 25
-})
-```
-
-````
-
-
diff --git a/archive/promise/fetch.js b/archive/promise/fetch.js
deleted file mode 100644
index b4719af836..0000000000
--- a/archive/promise/fetch.js
+++ /dev/null
@@ -1,37 +0,0 @@
-## Example: fetch
-
-
-## Example: fetch
-
-Promises are also returned by some built-in browser methods.
-
-For instance, [fetch](https://fetch.spec.whatwg.org/#fetch-method) allows to load arbitrary content over the network. We can use it to send information to the server and load data from it.
-
-The syntax is:
-
-```js
-let promise = fetch(url[, options]);
-```
-
-Here:
-- `url` is the URL to load,
-- `options` are various request options.
-
-There are many options, full information about them is in the [spec](https://fetch.spec.whatwg.org/#requestinit), here we won't need them.
-
-The promise returned by `fetch` resolves with the `response` object when the server responds.
-
-The most important properties of `response` are:
-- `status` -- HTTP-code: 200 for OK, 404 for "Page not found" etc.
-- `headers` -- HTTP headers.
-- 
-
-The important thing
-
-
-```js run
-fetch('/article/promise-chaining/1.html?speed=1')
-  .then(console.log);
-```
-
-
diff --git a/archive/promise/thenable.md b/archive/promise/thenable.md
deleted file mode 100644
index 7f528f1390..0000000000
--- a/archive/promise/thenable.md
+++ /dev/null
@@ -1,25 +0,0 @@
-````smart header="Thenables"
-To be precise, any object that has a method `.then` is treated as a promise here. So we can use custom "promise-compatible" objects in the chain. Such objects are called "thenable".
-
-Here's an example:
-
-```js run
-class Thenable {
-  constructor(result, delay) {
-    this.result = result;
-  }
-  then(resolve, reject) {
-    setTimeout(() => resolve(this.result * 2), delay);
-  }
-};
-
-new Promise(resolve => resolve(1))
-  .then(result => {
-    return new Thenable(result, 1000);
-  })
-  .then(alert); // shows 2 after 1000ms
-```
-
-That allows to use custom implementations of promises from 3rd-party libraries along with native promises.
-````
-
diff --git a/archive/promise/thenable2.js b/archive/promise/thenable2.js
deleted file mode 100644
index 3b72aaf3e7..0000000000
--- a/archive/promise/thenable2.js
+++ /dev/null
@@ -1,19 +0,0 @@
-'use strict';
-
-new Promise()
-  .then(result => {
-    return {
-      then(resolve, reject) {
-        setTimeout(() => resolve("two"), 1000);
-      }
-    };
-  })
-  .then(result => {
-    console.log("HERE", result);
-    return result;
-  })
-  .then(console.log)
-  .catch(err => console.error("ERROR", err));
-
-// https://tc39.github.io/ecma262/#sec-promise-resolve-functions
-
diff --git a/archive/promise/whereto.txt b/archive/promise/whereto.txt
deleted file mode 100644
index 2100b9b3b8..0000000000
--- a/archive/promise/whereto.txt
+++ /dev/null
@@ -1,58 +0,0 @@
-
-## Extending promises, thenables
-
-Promises are very simple by design. One of the thing they miss is the ability to cancel the process.
-
-For instance, `loadScript(src)` in previous examples returns a promise that allows to track success/failure of the loading. But can we abort it? No.
-
-We can inherit from `Promise` to introduce such functionality, like this:
-
-
-```js run
-function loadScript(src) {
-  let script = document.createElement('script');
-  alert(1);
-  script.src = src;
-
-  let promise = new Promise(function(resolve, reject) {
-    script.onload = () => { alert('onload'); resolve(script); }
-*!*
-    script.onerror = err => reject(new Error("Script load error: " + src)); // (*)
-*/!*
-  });
-
-  alert(2);
-
-  document.head.append(script);
-  alert(3);
-  promise.abort = () => {
-    script.src = 'javascript:""
-    ';
-  };
-  return promise;
-}
-
-let promise = loadScript("/article/promise-chaining/one.js?speed=0");
-promise.then(alert);
-promise.abort();
-alert(4);
-```
-
-
-
-
-
-
-
-## Inheriting from promise, thenables, promise api, async/await
-
---------
-
-
-An object that has a method called `.then` is called a "thenable".
-
-Instead of checking if something is `instanceof Promise`, we should usually check it for being thenable, and if it is, then treat it as a promise ("duck typing").
-
-JavaScript specification also checks the value returned by a handler for being a thenable, not exactly a promise, when it decides whether to pass it along the chain or wait for the result. So in the examples above we could use custom thenables instead of `Promise` instances.
-
-For instance, native promises give no way to "abort" the execution. The `loadScript` above cannot "cancel" script loading, just because there's no `.abort` method on promises, we can only listen for the state change using `.then/catch`.
diff --git a/archive/proto/user.js b/archive/proto/user.js
deleted file mode 100644
index e79d0b422a..0000000000
--- a/archive/proto/user.js
+++ /dev/null
@@ -1,16 +0,0 @@
-```js run
-function User(name, birthday) {
-  let age = calcAge();
-
-  function calcAge() {
-    new Date().getFullYear() - birthday.getFullYear();
-  }
-
-  this.sayHi = function() {
-    alert(name + ', age:' + age);
-  };
-}
-
-let user = new User("John", new Date(2000,0,1));
-user.sayHi(); // John
-```
diff --git a/archive/proto/wrong/javascript-prototype-confusion-and.html b/archive/proto/wrong/javascript-prototype-confusion-and.html
deleted file mode 100644
index abc8f71a16..0000000000
--- a/archive/proto/wrong/javascript-prototype-confusion-and.html
+++ /dev/null
@@ -1,1353 +0,0 @@
-<!DOCTYPE html>
-<html class='v2' dir='ltr' xmlns='http://www.w3.org/1999/xhtml' xmlns:b='http://www.google.com/2005/gml/b' xmlns:data='http://www.google.com/2005/gml/data' xmlns:expr='http://www.google.com/2005/gml/expr'>
-<head>
-<meta content='IE=EmulateIE7' http-equiv='X-UA-Compatible'/>
-<meta content='width=1100' name='viewport'/>
-<meta content='text/html; charset=UTF-8' http-equiv='Content-Type'/>
-<meta content='blogger' name='generator'/>
-<link href='http://www.nowherenearithaca.com/favicon.ico' rel='icon' type='image/x-icon'/>
-<link href='http://www.nowherenearithaca.com/2015/02/javascript-prototype-confusion-and.html' rel='canonical'/>
-<link rel="alternate" type="application/atom+xml" title="Nowhere Near Ithaca - Atom" href="http://www.nowherenearithaca.com/feeds/posts/default" />
-<link rel="alternate" type="application/rss+xml" title="Nowhere Near Ithaca - RSS" href="http://www.nowherenearithaca.com/feeds/posts/default?alt=rss" />
-<link rel="service.post" type="application/atom+xml" title="Nowhere Near Ithaca - Atom" href="https://www.blogger.com/feeds/7620301364506750761/posts/default" />
-
-<link rel="alternate" type="application/atom+xml" title="Nowhere Near Ithaca - Atom" href="http://www.nowherenearithaca.com/feeds/4739099319381019739/comments/default" />
-<!--[if IE]><script type="text/javascript" src="https://www.blogger.com/static/v1/jsbin/1803938243-ieretrofit.js"></script>
-<![endif]-->
-<link href='http://3.bp.blogspot.com/-6DxZ4q1TjVY/VN7J4aym7zI/AAAAAAAACjE/1BpYZ28BG40/s1600/Screen%2BShot%2B2015-02-13%2Bat%2B11.03.58%2BPM.png' rel='image_src'/>
-<meta content='http://www.nowherenearithaca.com/2015/02/javascript-prototype-confusion-and.html' property='og:url'/>
-<meta content='http://3.bp.blogspot.com/-6DxZ4q1TjVY/VN7J4aym7zI/AAAAAAAACjE/1BpYZ28BG40/w1200-h630-p-nu/Screen%2BShot%2B2015-02-13%2Bat%2B11.03.58%2BPM.png' property='og:image'/>
-<!--[if IE]> <script> (function() { let html5 = ("abbr,article,aside,audio,canvas,datalist,details," + "figure,footer,header,hgroup,mark,menu,meter,nav,output," + "progress,section,time,video").split(','); for (let i = 0; i < html5.length; i++) { document.createElement(html5[i]); } try { document.execCommand('BackgroundImageCache', false, true); } catch(e) {} })(); </script> <![endif]-->
-<title>Nowhere Near Ithaca: Javascript "Prototype" Confusion, and the Dubiously Useful "instanceof"</title>
-<link type='text/css' rel='stylesheet' href='https://www.blogger.com/static/v1/widgets/2340730481-css_bundle_v2.css' />
-<link type='text/css' rel='stylesheet' href='https://www.blogger.com/dyn-css/authorization.css?targetBlogID=7620301364506750761&zx=30835729-d154-494d-a7b3-dfa51767ecca' />
-<style id='page-skin-1' type='text/css'><!--
-/*
------------------------------------------------
-Blogger Template Style
-Name:     Simple
-Designer: Josh Peterson
-URL:      www.noaesthetic.com
------------------------------------------------ */
-/* Variable definitions
-====================
-<Variable name="keycolor" description="Main Color" type="color" default="#66bbdd"/>
-<Group description="Page Text" selector="body">
-<Variable name="body.font" description="Font" type="font"
-default="normal normal 12px Arial, Tahoma, Helvetica, FreeSans, sans-serif"/>
-<Variable name="body.text.color" description="Text Color" type="color" default="#222222"/>
-</Group>
-<Group description="Backgrounds" selector=".body-fauxcolumns-outer">
-<Variable name="body.background.color" description="Outer Background" type="color" default="#66bbdd"/>
-<Variable name="content.background.color" description="Main Background" type="color" default="#ffffff"/>
-<Variable name="header.background.color" description="Header Background" type="color" default="transparent"/>
-</Group>
-<Group description="Links" selector=".main-outer">
-<Variable name="link.color" description="Link Color" type="color" default="#2288bb"/>
-<Variable name="link.visited.color" description="Visited Color" type="color" default="#888888"/>
-<Variable name="link.hover.color" description="Hover Color" type="color" default="#33aaff"/>
-</Group>
-<Group description="Blog Title" selector=".header h1">
-<Variable name="header.font" description="Font" type="font"
-default="normal normal 60px Arial, Tahoma, Helvetica, FreeSans, sans-serif"/>
-<Variable name="header.text.color" description="Title Color" type="color" default="#3399bb" />
-</Group>
-<Group description="Blog Description" selector=".header .description">
-<Variable name="description.text.color" description="Description Color" type="color"
-default="#777777" />
-</Group>
-<Group description="Tabs Text" selector=".tabs-inner .widget li a">
-<Variable name="tabs.font" description="Font" type="font"
-default="normal normal 14px Arial, Tahoma, Helvetica, FreeSans, sans-serif"/>
-<Variable name="tabs.text.color" description="Text Color" type="color" default="#999999"/>
-<Variable name="tabs.selected.text.color" description="Selected Color" type="color" default="#000000"/>
-</Group>
-<Group description="Tabs Background" selector=".tabs-outer .PageList">
-<Variable name="tabs.background.color" description="Background Color" type="color" default="#f5f5f5"/>
-<Variable name="tabs.selected.background.color" description="Selected Color" type="color" default="#eeeeee"/>
-</Group>
-<Group description="Post Title" selector="h3.post-title, .comments h4">
-<Variable name="post.title.font" description="Font" type="font"
-default="normal normal 22px Arial, Tahoma, Helvetica, FreeSans, sans-serif"/>
-</Group>
-<Group description="Date Header" selector=".date-header">
-<Variable name="date.header.color" description="Text Color" type="color"
-default="#222222"/>
-<Variable name="date.header.background.color" description="Background Color" type="color"
-default="transparent"/>
-</Group>
-<Group description="Post Footer" selector=".post-footer">
-<Variable name="post.footer.text.color" description="Text Color" type="color" default="#666666"/>
-<Variable name="post.footer.background.color" description="Background Color" type="color"
-default="#f9f9f9"/>
-<Variable name="post.footer.border.color" description="Shadow Color" type="color" default="#eeeeee"/>
-</Group>
-<Group description="Gadgets" selector="h2">
-<Variable name="widget.title.font" description="Title Font" type="font"
-default="normal bold 11px Arial, Tahoma, Helvetica, FreeSans, sans-serif"/>
-<Variable name="widget.title.text.color" description="Title Color" type="color" default="#000000"/>
-<Variable name="widget.alternate.text.color" description="Alternate Color" type="color" default="#999999"/>
-</Group>
-<Group description="Images" selector=".main-inner">
-<Variable name="image.background.color" description="Background Color" type="color" default="#ffffff"/>
-<Variable name="image.border.color" description="Border Color" type="color" default="#eeeeee"/>
-<Variable name="image.text.color" description="Caption Text Color" type="color" default="#222222"/>
-</Group>
-<Group description="Accents" selector=".content-inner">
-<Variable name="body.rule.color" description="Separator Line Color" type="color" default="#eeeeee"/>
-<Variable name="tabs.border.color" description="Tabs Border Color" type="color" default="#eeeeee"/>
-</Group>
-<Variable name="body.background" description="Body Background" type="background"
-color="#f0f0f0" default="$(color) none repeat scroll top left"/>
-<Variable name="body.background.override" description="Body Background Override" type="string" default=""/>
-<Variable name="body.background.gradient.cap" description="Body Gradient Cap" type="url"
-default="url(http://www.blogblog.com/1kt/simple/gradients_light.png)"/>
-<Variable name="body.background.gradient.tile" description="Body Gradient Tile" type="url"
-default="url(http://www.blogblog.com/1kt/simple/body_gradient_tile_light.png)"/>
-<Variable name="content.background.color.selector" description="Content Background Color Selector" type="string" default=".content-inner"/>
-<Variable name="content.padding" description="Content Padding" type="length" default="10px"/>
-<Variable name="content.padding.horizontal" description="Content Horizontal Padding" type="length" default="10px"/>
-<Variable name="content.shadow.spread" description="Content Shadow Spread" type="length" default="40px"/>
-<Variable name="content.shadow.spread.webkit" description="Content Shadow Spread (WebKit)" type="length" default="5px"/>
-<Variable name="content.shadow.spread.ie" description="Content Shadow Spread (IE)" type="length" default="10px"/>
-<Variable name="main.border.width" description="Main Border Width" type="length" default="0"/>
-<Variable name="header.background.gradient" description="Header Gradient" type="url" default="none"/>
-<Variable name="header.shadow.offset.left" description="Header Shadow Offset Left" type="length" default="-1px"/>
-<Variable name="header.shadow.offset.top" description="Header Shadow Offset Top" type="length" default="-1px"/>
-<Variable name="header.shadow.spread" description="Header Shadow Spread" type="length" default="1px"/>
-<Variable name="header.padding" description="Header Padding" type="length" default="15px"/>
-<Variable name="header.border.size" description="Header Border Size" type="length" default="1px"/>
-<Variable name="header.bottom.border.size" description="Header Bottom Border Size" type="length" default="1px"/>
-<Variable name="header.border.horizontalsize" description="Header Horizontal Border Size" type="length" default="0"/>
-<Variable name="description.text.size" description="Description Text Size" type="string" default="140%"/>
-<Variable name="tabs.margin.top" description="Tabs Margin Top" type="length" default="0" />
-<Variable name="tabs.margin.side" description="Tabs Side Margin" type="length" default="30px" />
-<Variable name="tabs.background.gradient" description="Tabs Background Gradient" type="url"
-default="url(http://www.blogblog.com/1kt/simple/gradients_light.png)"/>
-<Variable name="tabs.border.width" description="Tabs Border Width" type="length" default="1px"/>
-<Variable name="tabs.bevel.border.width" description="Tabs Bevel Border Width" type="length" default="1px"/>
-<Variable name="date.header.padding" description="Date Header Padding" type="string" default="inherit"/>
-<Variable name="date.header.letterspacing" description="Date Header Letter Spacing" type="string" default="inherit"/>
-<Variable name="date.header.margin" description="Date Header Margin" type="string" default="inherit"/>
-<Variable name="post.margin.bottom" description="Post Bottom Margin" type="length" default="25px"/>
-<Variable name="image.border.small.size" description="Image Border Small Size" type="length" default="2px"/>
-<Variable name="image.border.large.size" description="Image Border Large Size" type="length" default="5px"/>
-<Variable name="page.width.selector" description="Page Width Selector" type="string" default=".region-inner"/>
-<Variable name="page.width" description="Page Width" type="string" default="auto"/>
-<Variable name="main.section.margin" description="Main Section Margin" type="length" default="15px"/>
-<Variable name="main.padding" description="Main Padding" type="length" default="15px"/>
-<Variable name="main.padding.top" description="Main Padding Top" type="length" default="30px"/>
-<Variable name="main.padding.bottom" description="Main Padding Bottom" type="length" default="30px"/>
-<Variable name="paging.background"
-color="#ffffff"
-description="Background of blog paging area" type="background"
-default="transparent none no-repeat scroll top center"/>
-<Variable name="footer.bevel" description="Bevel border length of footer" type="length" default="0"/>
-<Variable name="mobile.background.overlay" description="Mobile Background Overlay" type="string"
-default="transparent none repeat scroll top left"/>
-<Variable name="mobile.background.size" description="Mobile Background Size" type="string" default="auto"/>
-<Variable name="mobile.button.color" description="Mobile Button Color" type="color" default="#ffffff" />
-<Variable name="startSide" description="Side where text starts in blog language" type="automatic" default="left"/>
-<Variable name="endSide" description="Side where text ends in blog language" type="automatic" default="right"/>
-*/
-/* Content
------------------------------------------------ */
-body {
-font: normal normal 14px Georgia, Utopia, 'Palatino Linotype', Palatino, serif;
-color: #222222;
-background: #f0f0f0 none repeat scroll top left;
-padding: 0 40px 40px 40px;
-}
-html body .region-inner {
-min-width: 0;
-max-width: 100%;
-width: auto;
-}
-a:link {
-text-decoration:none;
-color: #2288bb;
-}
-a:visited {
-text-decoration:none;
-color: #888888;
-}
-a:hover {
-text-decoration:underline;
-color: #33aaff;
-}
-.body-fauxcolumn-outer .fauxcolumn-inner {
-background: transparent url(http://www.blogblog.com/1kt/simple/body_gradient_tile_light.png) repeat scroll top left;
-_background-image: none;
-}
-.body-fauxcolumn-outer .cap-top {
-position: absolute;
-z-index: 1;
-height: 400px;
-width: 100%;
-background: #f0f0f0 none repeat scroll top left;
-}
-.body-fauxcolumn-outer .cap-top .cap-left {
-width: 100%;
-background: transparent url(http://www.blogblog.com/1kt/simple/gradients_light.png) repeat-x scroll top left;
-_background-image: none;
-}
-.content-outer {
--moz-box-shadow: 0 0 40px rgba(0, 0, 0, .15);
--webkit-box-shadow: 0 0 5px rgba(0, 0, 0, .15);
--goog-ms-box-shadow: 0 0 10px #333333;
-box-shadow: 0 0 40px rgba(0, 0, 0, .15);
-margin-bottom: 1px;
-}
-.content-inner {
-padding: 10px 10px;
-}
-.content-inner {
-background-color: #ffffff;
-}
-/* Header
------------------------------------------------ */
-.header-outer {
-background: transparent none repeat-x scroll 0 -400px;
-_background-image: none;
-}
-.Header h1 {
-font: italic normal 60px Georgia, Utopia, 'Palatino Linotype', Palatino, serif;
-color: #000000;
-text-shadow: -1px -1px 1px rgba(0, 0, 0, .2);
-}
-.Header h1 a {
-color: #000000;
-}
-.Header .description {
-font-size: 140%;
-color: #777777;
-}
-.header-inner .Header .titlewrapper {
-padding: 6px 15px;
-}
-.header-inner .Header .descriptionwrapper {
-padding: 0 15px;
-}
-/* Tabs
------------------------------------------------ */
-.tabs-inner .section:first-child {
-border-top: 1px solid #eeeeee;
-}
-.tabs-inner .section:first-child ul {
-margin-top: -1px;
-border-top: 1px solid #eeeeee;
-border-left: 0 solid #eeeeee;
-border-right: 0 solid #eeeeee;
-}
-.tabs-inner .widget ul {
-background: #f5f5f5 url(http://www.blogblog.com/1kt/simple/gradients_light.png) repeat-x scroll 0 -800px;
-_background-image: none;
-border-bottom: 1px solid #eeeeee;
-margin-top: 0;
-margin-left: -30px;
-margin-right: -30px;
-}
-.tabs-inner .widget li a {
-display: inline-block;
-padding: .6em 1em;
-font: normal normal 14px Arial, Tahoma, Helvetica, FreeSans, sans-serif;
-color: #999999;
-border-left: 1px solid #ffffff;
-border-right: 1px solid #eeeeee;
-}
-.tabs-inner .widget li:first-child a {
-border-left: none;
-}
-.tabs-inner .widget li.selected a, .tabs-inner .widget li a:hover {
-color: #000000;
-background-color: #eeeeee;
-text-decoration: none;
-}
-/* Columns
------------------------------------------------ */
-.main-outer {
-border-top: 0 solid #eeeeee;
-}
-.fauxcolumn-left-outer .fauxcolumn-inner {
-border-right: 1px solid #eeeeee;
-}
-.fauxcolumn-right-outer .fauxcolumn-inner {
-border-left: 1px solid #eeeeee;
-}
-/* Headings
------------------------------------------------ */
-h2 {
-margin: 0 0 1em 0;
-font: normal bold 11px Arial, Tahoma, Helvetica, FreeSans, sans-serif;
-color: #000000;
-text-transform: uppercase;
-}
-/* Widgets
------------------------------------------------ */
-.widget .zippy {
-color: #999999;
-text-shadow: 2px 2px 1px rgba(0, 0, 0, .1);
-}
-.widget .popular-posts ul {
-list-style: none;
-}
-/* Posts
------------------------------------------------ */
-.date-header span {
-background-color: transparent;
-color: #222222;
-padding: inherit;
-letter-spacing: inherit;
-margin: inherit;
-}
-.main-inner {
-padding-top: 30px;
-padding-bottom: 30px;
-}
-.main-inner .column-center-inner {
-padding: 0 15px;
-}
-.main-inner .column-center-inner .section {
-margin: 0 15px;
-}
-.post {
-margin: 0 0 25px 0;
-}
-h3.post-title, .comments h4 {
-font: normal bold 24px Georgia, Utopia, 'Palatino Linotype', Palatino, serif;
-margin: .75em 0 0;
-}
-.post-body {
-font-size: 110%;
-line-height: 1.4;
-position: relative;
-}
-.post-body img, .post-body .tr-caption-container, .Profile img, .Image img,
-.BlogList .item-thumbnail img {
-padding: 2px;
-background: #ffffff;
-border: 1px solid #eeeeee;
--moz-box-shadow: 1px 1px 5px rgba(0, 0, 0, .1);
--webkit-box-shadow: 1px 1px 5px rgba(0, 0, 0, .1);
-box-shadow: 1px 1px 5px rgba(0, 0, 0, .1);
-}
-.post-body img, .post-body .tr-caption-container {
-padding: 5px;
-}
-.post-body .tr-caption-container {
-color: #222222;
-}
-.post-body .tr-caption-container img {
-padding: 0;
-background: transparent;
-border: none;
--moz-box-shadow: 0 0 0 rgba(0, 0, 0, .1);
--webkit-box-shadow: 0 0 0 rgba(0, 0, 0, .1);
-box-shadow: 0 0 0 rgba(0, 0, 0, .1);
-}
-.post-header {
-margin: 0 0 1.5em;
-line-height: 1.6;
-font-size: 90%;
-}
-.post-footer {
-margin: 20px -2px 0;
-padding: 5px 10px;
-color: #666666;
-background-color: #f9f9f9;
-border-bottom: 1px solid #eeeeee;
-line-height: 1.6;
-font-size: 90%;
-}
-#comments .comment-author {
-padding-top: 1.5em;
-border-top: 1px solid #eeeeee;
-background-position: 0 1.5em;
-}
-#comments .comment-author:first-child {
-padding-top: 0;
-border-top: none;
-}
-.avatar-image-container {
-margin: .2em 0 0;
-}
-#comments .avatar-image-container img {
-border: 1px solid #eeeeee;
-}
-/* Comments
------------------------------------------------ */
-.comments .comments-content .icon.blog-author {
-background-repeat: no-repeat;
-background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABIAAAASCAYAAABWzo5XAAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAALEgAACxIB0t1+/AAAAAd0SU1FB9sLFwMeCjjhcOMAAAD+SURBVDjLtZSvTgNBEIe/WRRnm3U8RC1neQdsm1zSBIU9VVF1FkUguQQsD9ITmD7ECZIJSE4OZo9stoVjC/zc7ky+zH9hXwVwDpTAWWLrgS3QAe8AZgaAJI5zYAmc8r0G4AHYHQKVwII8PZrZFsBFkeRCABYiMh9BRUhnSkPTNCtVXYXURi1FpBDgArj8QU1eVXUzfnjv7yP7kwu1mYrkWlU33vs1QNu2qU8pwN0UpKoqokjWwCztrMuBhEhmh8bD5UDqur75asbcX0BGUB9/HAMB+r32hznJgXy2v0sGLBcyAJ1EK3LFcbo1s91JeLwAbwGYu7TP/3ZGfnXYPgAVNngtqatUNgAAAABJRU5ErkJggg==);
-}
-.comments .comments-content .loadmore a {
-border-top: 1px solid #999999;
-border-bottom: 1px solid #999999;
-}
-.comments .comment-thread.inline-thread {
-background-color: #f9f9f9;
-}
-.comments .continue {
-border-top: 2px solid #999999;
-}
-/* Accents
----------------------------------------------- */
-.section-columns td.columns-cell {
-border-left: 1px solid #eeeeee;
-}
-.blog-pager {
-background: transparent none no-repeat scroll top center;
-}
-.blog-pager-older-link, .home-link,
-.blog-pager-newer-link {
-background-color: #ffffff;
-padding: 5px;
-}
-.footer-outer {
-border-top: 0 dashed #bbbbbb;
-}
-/* Mobile
------------------------------------------------ */
-body.mobile  {
-background-size: auto;
-}
-.mobile .body-fauxcolumn-outer {
-background: transparent none repeat scroll top left;
-}
-.mobile .body-fauxcolumn-outer .cap-top {
-background-size: 100% auto;
-}
-.mobile .content-outer {
--webkit-box-shadow: 0 0 3px rgba(0, 0, 0, .15);
-box-shadow: 0 0 3px rgba(0, 0, 0, .15);
-padding: 0 40px;
-}
-body.mobile .AdSense {
-margin: 0 -40px;
-}
-.mobile .tabs-inner .widget ul {
-margin-left: 0;
-margin-right: 0;
-}
-.mobile .post {
-margin: 0;
-}
-.mobile .main-inner .column-center-inner .section {
-margin: 0;
-}
-.mobile .date-header span {
-padding: 0.1em 10px;
-margin: 0 -10px;
-}
-.mobile h3.post-title {
-margin: 0;
-}
-.mobile .blog-pager {
-background: transparent none no-repeat scroll top center;
-}
-.mobile .footer-outer {
-border-top: none;
-}
-.mobile .main-inner, .mobile .footer-inner {
-background-color: #ffffff;
-}
-.mobile-index-contents {
-color: #222222;
-}
-.mobile-link-button {
-background-color: #2288bb;
-}
-.mobile-link-button a:link, .mobile-link-button a:visited {
-color: #ffffff;
-}
-.mobile .tabs-inner .section:first-child {
-border-top: none;
-}
-.mobile .tabs-inner .PageList .widget-content {
-background-color: #eeeeee;
-color: #000000;
-border-top: 1px solid #eeeeee;
-border-bottom: 1px solid #eeeeee;
-}
-.mobile .tabs-inner .PageList .widget-content .pagelist-arrow {
-border-left: 1px solid #eeeeee;
-}
-.kwd{color:#93C763}
-.com{color:#66747B}
-.typ{color:#678CB1}
-.lit{color:#FACD22}
-.tag{color:#8AC763}
-.atn{color:#E0E2E4}
-.dec{color:purple}
-pre.prettyprint{border:0 solid #888}
-.prettyprint{background:#000}
-li.L0,li.L1,li.L2,li.L3,li.L4,li.L5,li.L6,li.L7,li.L8,li.L9{color:#555;list-style-type:decimal}
-li.L1,li.L3,li.L5,li.L7,li.L9{background:#111}
-.str,.atv{color:#EC7600}
-.pun,.pln{color:#F1F2F3}
-.prettyprinted{word-wrap:break-word;background:#000;border-radius:10px}
-@media print {
-.com{color:#600;font-style:italic}
-.typ{color:#404;font-weight:700}
-.lit{color:#044}
-.pun{color:#440}
-.pln{color:#000}
-.atn{color:#404}
-.str,.atv{color:#060}
-.kwd,.tag{color:#006;font-weight:700}
-}.descriptionwrapper {
-margin-bottom:5px !important;
-}
-.Header h1 {
-margin-bottom:2px !important;
-}
-.titlewrapper {
-line-height:1.01 !important;
-padding-bottom:1px !important;
-}
-.main-inner {
-padding-top:5px !important;
-}
-.post-title {
-margin-top:5px !important;
-}
---></style>
-<style id='template-skin-1' type='text/css'><!--
-body {
-min-width: 1024px;
-}
-.content-outer, .content-fauxcolumn-outer, .region-inner {
-min-width: 1024px;
-max-width: 1024px;
-_width: 1024px;
-}
-.main-inner .columns {
-padding-left: 0px;
-padding-right: 200px;
-}
-.main-inner .fauxcolumn-center-outer {
-left: 0px;
-right: 200px;
-/* IE6 does not respect left and right together */
-_width: expression(this.parentNode.offsetWidth -
-parseInt("0px") -
-parseInt("200px") + 'px');
-}
-.main-inner .fauxcolumn-left-outer {
-width: 0px;
-}
-.main-inner .fauxcolumn-right-outer {
-width: 200px;
-}
-.main-inner .column-left-outer {
-width: 0px;
-right: 100%;
-margin-left: -0px;
-}
-.main-inner .column-right-outer {
-width: 200px;
-margin-right: -200px;
-}
-#layout {
-min-width: 0;
-}
-#layout .content-outer {
-min-width: 0;
-width: 800px;
-}
-#layout .region-inner {
-min-width: 0;
-width: auto;
-}
---></style>
-<script src='http://cdn.mathjax.org/mathjax/latest/MathJax.js' type='text/javascript'>    
-    MathJax.Hub.Config({
-        HTML: ["input/TeX","output/HTML-CSS"],
-        TeX: { extensions: ["AMSmath.js","AMSsymbols.js"], 
-               equationNumbers: { autoNumber: "AMS" } },
-        extensions: ["tex2jax.js"],
-        jax: ["input/TeX","output/HTML-CSS"],
-        tex2jax: { inlineMath: [ ['$','$'], ["\\(","\\)"] ],
-                   displayMath: [ ['$$','$$'], ["\\[","\\]"] ],
-                   processEscapes: true },
-        "HTML-CSS": { availableFonts: ["TeX"],
-                      linebreaks: { automatic: true } }
-    });
-</script>
-<script type="text/javascript">function a(){let b=window.location.href,c=b.split("?");switch(c.length){case 1:return b+"?m=1";case 2:return 0<=c[1].search("(^|&)m=")?null:b+"&m=1";default:return null}}let d=navigator.userAgent;if(-1!=d.indexOf("Mobile")&&-1!=d.indexOf("WebKit")&&-1==d.indexOf("iPad")||-1!=d.indexOf("Opera Mini")||-1!=d.indexOf("IEMobile")){let e=a();e&&window.location.replace(e)};
-</script></head>
-<body class='loading'>
-<div class='navbar section' id='navbar'><div class='widget Navbar' data-version='1' id='Navbar1'><script type="text/javascript">
-    function setAttributeOnload(object, attribute, val) {
-      if(window.addEventListener) {
-        window.addEventListener('load',
-          function(){ object[attribute] = val; }, false);
-      } else {
-        window.attachEvent('onload', function(){ object[attribute] = val; });
-      }
-    }
-  </script>
-<div id="navbar-iframe-container"></div>
-<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
-<script type="text/javascript">
-      gapi.load("gapi.iframes:gapi.iframes.style.bubble", function() {
-        if (gapi.iframes && gapi.iframes.getContext) {
-          gapi.iframes.getContext().openChild({
-              url: 'https://www.blogger.com/navbar.g?targetBlogID\x3d7620301364506750761\x26blogName\x3dNowhere+Near+Ithaca\x26publishMode\x3dPUBLISH_MODE_HOSTED\x26navbarType\x3dBLUE\x26layoutType\x3dLAYOUTS\x26searchRoot\x3dhttp://www.nowherenearithaca.com/search\x26blogLocale\x3den\x26v\x3d2\x26homepageUrl\x3dhttp://www.nowherenearithaca.com/\x26targetPostID\x3d4739099319381019739\x26blogPostOrPageUrl\x3dhttp://www.nowherenearithaca.com/2015/02/javascript-prototype-confusion-and.html\x26vt\x3d3808413806741874143',
-              where: document.getElementById("navbar-iframe-container"),
-              id: "navbar-iframe"
-          });
-        }
-      });
-    </script><script type="text/javascript">
-(function() {
-let script = document.createElement('script');
-script.type = 'text/javascript';
-script.src = '//pagead2.googlesyndication.com/pagead/js/google_top_exp.js';
-let head = document.getElementsByTagName('head')[0];
-if (head) {
-head.appendChild(script);
-}})();
-</script>
-</div></div>
-<div class='body-fauxcolumns'>
-<div class='fauxcolumn-outer body-fauxcolumn-outer'>
-<div class='cap-top'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-<div class='fauxborder-left'>
-<div class='fauxborder-right'></div>
-<div class='fauxcolumn-inner'>
-</div>
-</div>
-<div class='cap-bottom'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-</div>
-</div>
-<div class='content'>
-<div class='content-fauxcolumns'>
-<div class='fauxcolumn-outer content-fauxcolumn-outer'>
-<div class='cap-top'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-<div class='fauxborder-left'>
-<div class='fauxborder-right'></div>
-<div class='fauxcolumn-inner'>
-</div>
-</div>
-<div class='cap-bottom'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-</div>
-</div>
-<div class='content-outer'>
-<div class='content-cap-top cap-top'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-<div class='fauxborder-left content-fauxborder-left'>
-<div class='fauxborder-right content-fauxborder-right'></div>
-<div class='content-inner'>
-<header>
-<div class='header-outer'>
-<div class='header-cap-top cap-top'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-<div class='fauxborder-left header-fauxborder-left'>
-<div class='fauxborder-right header-fauxborder-right'></div>
-<div class='region-inner header-inner'>
-<div class='header section' id='header'><div class='widget Header' data-version='1' id='Header1'>
-<div id='header-inner'>
-<div class='titlewrapper'>
-<h1 class='title'>
-<a href='http://www.nowherenearithaca.com/'>Nowhere Near Ithaca</a>
-</h1>
-</div>
-<div class='descriptionwrapper'>
-<p class='description'><span>In search of the Ahh and Aha via Data Visualization.
-<br>
-<a href="mailto:bradflyon@gmail.com">bradflyon@gmail.com</a>
-<br href="nowhere">
-<a href="http://www.nowherenearithaca.com/2014/02/a-summary-of-some-of-my-visualizations.html">A Summary of My Visualizations</a>
-<br>
-<a href="http://learnforeverlearn.com/hm/">About Me</a></span></p>
-</div>
-</div>
-</div></div>
-</div>
-</div>
-<div class='header-cap-bottom cap-bottom'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-</div>
-</header>
-<div class='tabs-outer'>
-<div class='tabs-cap-top cap-top'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-<div class='fauxborder-left tabs-fauxborder-left'>
-<div class='fauxborder-right tabs-fauxborder-right'></div>
-<div class='region-inner tabs-inner'>
-<div class='tabs no-items section' id='crosscol'></div>
-<div class='tabs no-items section' id='crosscol-overflow'></div>
-</div>
-</div>
-<div class='tabs-cap-bottom cap-bottom'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-</div>
-<div class='main-outer'>
-<div class='main-cap-top cap-top'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-<div class='fauxborder-left main-fauxborder-left'>
-<div class='fauxborder-right main-fauxborder-right'></div>
-<div class='region-inner main-inner'>
-<div class='columns fauxcolumns'>
-<div class='fauxcolumn-outer fauxcolumn-center-outer'>
-<div class='cap-top'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-<div class='fauxborder-left'>
-<div class='fauxborder-right'></div>
-<div class='fauxcolumn-inner'>
-</div>
-</div>
-<div class='cap-bottom'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-</div>
-<div class='fauxcolumn-outer fauxcolumn-left-outer'>
-<div class='cap-top'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-<div class='fauxborder-left'>
-<div class='fauxborder-right'></div>
-<div class='fauxcolumn-inner'>
-</div>
-</div>
-<div class='cap-bottom'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-</div>
-<div class='fauxcolumn-outer fauxcolumn-right-outer'>
-<div class='cap-top'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-<div class='fauxborder-left'>
-<div class='fauxborder-right'></div>
-<div class='fauxcolumn-inner'>
-</div>
-</div>
-<div class='cap-bottom'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-</div>
-<!-- corrects IE6 width calculation -->
-<div class='columns-inner'>
-<div class='column-center-outer'>
-<div class='column-center-inner'>
-<div class='main section' id='main'><div class='widget Blog' data-version='1' id='Blog1'>
-<div class='blog-posts hfeed'>
-
-          <div class="date-outer">
-        
-
-          <div class="date-posts">
-        
-<div class='post-outer'>
-<div class='post hentry' itemscope='itemscope' itemtype='http://schema.org/BlogPosting'>
-<a name='4739099319381019739'></a>
-<h3 class='post-title entry-title' itemprop='name'>
-Javascript "Prototype" Confusion, and the Dubiously Useful "instanceof"
-</h3>
-<div class='post-header'>
-<div class='post-header-line-1'></div>
-</div>
-<div class='post-body entry-content' id='post-body-4739099319381019739' itemprop='articleBody'>
-
-
-<link href="http://yandex.st/highlightjs/7.5/styles/default.min.css" rel="stylesheet">
-<script src="http://yandex.st/highlightjs/7.5/highlight.min.js"></script>
-
-<script>hljs.initHighlightingOnLoad();</script>
-
-<style>
- .main {
-   font-size:18px;
- }
-
-.descriptionwrapper [href*='learnforever'] {
-
-  display:none !important;
-
-}
-
-
-.command {
-  padding-left:4px;
-  padding-right:4px;
-  border: 1px solid #ddd;
-  border-radius:3px;
-  background:#f8f8f8;
-}
-
-code {
-
-  padding-left:4px;
-  padding-right:4px;
-  border: 1px solid #eee;
-  border-radius:3px;
-  ibackground:#f8f8f8;
-  background:#f9f9f5;
-
-
-  font-size:90%;
-  font-family:inherit;
-
-  iborder-radius:5px;
-  iborder:1px solid #888;
-}
-
-span.keyword, code .keyword {
-    color: rgb(170, 13, 145);
-    font-weight:normal;
-  }
-  code .comment {
-    color: rgb(0,116,0);
-    font-weight:normal;
-  }
-  code .title {
-   color:black; 
-   font-weight:normal;
-  }
-  code .number {color: rgb(28, 0, 207);}
-  code .string {color: rgb(196, 26, 22);}
-
-
-.imageTitle {
-  font-size:100%;
-  text-align:center;
-  font-weight:bold;
-}
-
-.mySection {
-  margin-top:15px;
-  margin-bottom:10px;
-  font-size:120%;
-  font-weight:bold;
-}
-
-.mySubSection {
-  margin-top:15px;
-  margin-bottom:10px;
-  font-size:110%;
-  font-weight:bold;
-}
-
-blockquote {
-  ifont: 14px/22px normal helvetica, sans-serif;
-  font: normal helvetica, sans-serif;
-  margin-top: 10px;
-  margin-bottom: 10px;
-  margin-left: 50px;
-  padding-left: 15px;
-  border-left: 3px solid #ccc;
-} 
-
-blockquote p {
-  ifont-style:italic;
-}
-
-.warning {
-
-  ifont-weight:bold;
-
-}
-
-</style>
-
-<div class="main">
-
-<!--
-<blockquote>
-    <p>Curious madness reigns when different things are named the same.</p>
-</blockquote>
--->
-
-<p>Recently, I became aware that I was more confused than I realized regarding javascript's use of the word "prototype", as the word is used in two different ways.  
-</p>
-<p>This draft note is the result of pondering on this a bit more.  This pondering also resulted in some clarification (for me) of how the <code>instanceof</code> operator seems to work, and how its utility is doubtful.
-</p>
-
-<a name='more'></a>
-
-<!--
-<div class="mySection">
-  Javascript and its Confusing Use of the Word "prototype"
-</div>
--->
-
-
-<div class="mySubSection">
-Every object has a prototype, accessed via its "__proto__" property
-</div>
-
-<p>Javascript objects are just bags of named things: properties.  Properties can be other objects, functions (which are also objects), or primitives like numbers and strings.  </p>
-
-<p>Every javascript object has a prototype, which can be accessed directly in most modern browsers via the named property <code>__proto__</code>. </p>
-
-<p>
-When a property named <code>foo</code> is requested from an object <code>obj</code> via <code>obj.foo</code>, first the set of properties for object itself is searched for the property.  If it is not found, then <code>obj.__proto__</code> is searched for a property named <code>foo</code>.  If not found there, then it searches <code>obj.__proto__.__proto__</code>, continuing up the "prototype chain" until it either finds the property or <code>obj.__proto__.__proto__....__proto__</code> is null, and <code>undefined</code> is returned.  
-Note that the javascript engine is supposed to prevent cyclic loops in the prototype chain.
-</p>
-
-
-<p><span class="warning">Again: the name of the property for the prototype of an object is not "prototype"</span>: its name is "__proto__".</p>
-
-<p>That is one part of the potential confusion.</p>
-
-<!--
--->
-
-<div class="mySubSection">
-Every javascript function <code>f</code> has a property named "prototype" - which is not its prototype
-</div>
-
-
-<p>This is another part of the potential confusion.</p>
-
-<p>
-<span class="warning"><code>f.prototype</code>is not the function's
-        prototype.</span>  
-</p>
-
-<p>
-As for any object, <code>f.__proto__</code> is the function's prototype.
-</p>
-
-<div class="mySubSection">
-What is the purpose of <code>f.prototype</code>?
-</div>
-
-<p>Any function <code>f</code> can be used to generate new objects via <code>newObject = new f(args)</code>.
-When used this way, <code>f</code> is sometimes called the "constructor" for <code>newObject</code>.
-<!--  <span class="warning">Any function can be used as a constructor to make new objects.
-</span>  
--->
-</p>
-
-<p>When an object is created from a function <code>f</code> via <code>newObject = new f(args)</code>, the new object's prototype <code>__proto__</code>
-property is set to the property named "prototype" of <code>f</code>:  
-<code>newObject.__proto__ = f.prototype </code>.</p>
-
-<p>That is what <code>f.prototype</code> is used for.</p>
-
-<p>Note that there are other ways to create an object with a specified prototype, and in fact these other methods are recommended by some folks, avoiding the "new" keyword altogether.</p>
-
-<div class="mySection">
-Aside: The "constructor" Property
-</div>
-
-<p>While every function can be used as a constructor, there is also a property named "constructor" for some objects.</p>
-
-<p>
-In particular, for any function <code>f</code>,  <code>f.prototype.constructor = f</code>.
-</p>
-
-<p>Since objects created from <code>f</code> via <code>new f(args)</code> have their "__proto__" property initialized to <code>f.prototype</code>, this means that for any object <code>newObject</code> created via <code>newObject = new f(args)</code> for some function <code>f</code>, <code>newObject.constructor</code> will refer to the function used to create the object.  Initially, at least, as you can change the <code>constructor</code> later.
-</p>
-
-<p>Other than a record of the object's ancestry that might be useful in a handful of cases (that I've never encountered), I don't know how the knowledge of the constructor would be generally useful.</p>
-
-
-<div class="mySection">
-  What this has to do with how javascript's <code>instanceof</code> works
-</div>
-
-<p>Javascript has an <code>instanceof</code> operator that returns true or false, and can be called like so:
-<pre><code>obj instanceof f
-</code></pre>
-<p>You can only use a function on the right side: <code>instanceof</code> will throw an error if <code>f</code> is not a function.</p>
-
-<p>The Mozilla Developer network <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof">summarizes this operator quite succinctly</a>  (I have used "function" instead of "constructor", since every function can be a constructor):
-
-<blockquote>
-The instanceof operator tests whether an object has in its prototype chain the prototype property of a given function.
-</blockquote>
-
-</p>
-
-<!--
-<p>Note: Remember that every function can be used as a constructor, so "constructor" and "function" are really synonyms here.<p>
--->
-
-
-<!--
-<p>You might thing this returns true if <code>obj.constructor === someFunction</code>, since that would imply that <code>obj</code> had been created via <code>obj = new someFunction()</code>.  
-</p>
--->
-<!--Of course, if thinking in a classical OOP way, something could be an instance of something else if its parent class was built fromFunction, or its parent's parent, etc.</p>
--->
-
- 
-<p>This is illustrated in the figure below.</p>
-
-
-<!--
-<p>It's actually a stronger comparison check that is performed, as indicated in the figure below.</p>
--->
-
-<!--
-<div class="separator" style="clear: both; text-align: center;"><a href="http://3.bp.blogspot.com/-6DxZ4q1TjVY/VN7J4aym7zI/AAAAAAAACjE/1BpYZ28BG40/s1600/Screen%2BShot%2B2015-02-13%2Bat%2B11.03.58%2BPM.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="http://3.bp.blogspot.com/-6DxZ4q1TjVY/VN7J4aym7zI/AAAAAAAACjE/1BpYZ28BG40/s1600/Screen%2BShot%2B2015-02-13%2Bat%2B11.03.58%2BPM.png" /></a></div>
--->
-<div class="separator" style="clear: both; text-align: center;"><a href="http://1.bp.blogspot.com/-x-pC59QdbIQ/VODjCYbRaCI/AAAAAAAACjY/G3CNlkryfWI/s1600/Screen%2BShot%2B2015-02-15%2Bat%2B1.17.53%2BPM.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="http://1.bp.blogspot.com/-x-pC59QdbIQ/VODjCYbRaCI/AAAAAAAACjY/G3CNlkryfWI/s1600/Screen%2BShot%2B2015-02-15%2Bat%2B1.17.53%2BPM.png" /></a></div>
-
-<div class="imageTitle">
-(<code>obj</code> instanceof <code>f
-</code>) is true
-if <code>f.prototype</code> is equal to
-<br/>
-any <code>__proto__</code> in
-the prototype chain of <code>obj</code>
-</div>
-
-<div class="mySubSection">Do People Use <code>instanceof</code>?</div>
-
-<p>Answer: I think few do.</p>
-
-<!--
-<p>How often to folks even use the <code>instanceof</code> operator?  I don't think very often. 
-</p>
--->
-
-<p> When <a href="https://twitter.com/bflyon/status/564456480318173185">queried on twitter</a>, both <a href="https://twitter.com/_ericelliott">Eric Elliot</a> and <a href="https://twitter.com/getify">Kyle Simpson</a> (two javascript folks I think a lot of) tweeted back that they never did.  When I <a href="https://news.ycombinator.com/item?id=9031262">asked on hacker news</a>, one commenter said it was a code smell, while another said it was useful when checking if an object is an array (it should be noted that jquery checks the result of a toString call to determine if something is an array).</p>
-
-<p>There are also problems with trying to use <code>instanceof</code> across iframes.</p>
-
-<p><a href="https://twitter.com/kangax">@kangax</a> <a href="http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/">discourages its use</a> (2009).  He also recommends the same method jquery uses to check if something is an array, btw.<p>
-
-<p>Crockford has remarked (in 2003) about the <a href="https://groups.google.com/forum/#!msg/comp.lang.javascript/XTWYCOwC96I/70rNoQ3L-xoJ">useless instanceof operator</a> (link via kangax's article).<p>
-
-<p>So, I don't foresee using it much myself, but it is personally satisfying to come to a better understanding of it and the surrounding javascript constructs.</p>
-
-
-
-<!--
-<p>This operator will return true if <code>someFunction.prototype</code> is equal to 
-<code>obj.__proto__</code>, or
-<code>obj.__proto__.__proto__</code>, etc.
-</p>
--->
-
-
-<div class="mySection">
-And be Warned...
-</div>
-
-
-<p>Compared to "standard" OOP that can result in rigid, iron-like structures that complicate change and reuse, javascript with its prototype-based reuse pattern is as firm as a jello: you can change things bit more willy-nilly, if you so desire.</p>
-
-<p>In particular, you can muck with the prototype and constructor properties after-the-fact, and this would likely invalidate the notes above in whatever curious ways you (or the code you are using) has mucked with things.</p>
-
-<!--
-<p>While this malleability complicates cut-and-dry attempts at understanding and explaining, it also results in, as <a href="http://javascript.crockford.com/survey.html">noted by Crockford in 2002</a>, a "powerful and expressive language."  And, imo, there be beauty afoot as well.</p>
--->
-
-</div>
-<div style='clear: both;'></div>
-</div>
-<div class='post-footer'>
-<div class='post-footer-line post-footer-line-1'><span class='post-author vcard'>
-Posted by
-<span class='fn'>
-<a href='https://plus.google.com/102736576072808601046' itemprop='author' rel='author' title='author profile'>
-B Lyon
-</a>
-</span>
-</span>
-<span class='post-comment-link'>
-</span>
-<span class='post-icons'>
-<span class='item-control blog-admin pid-1612364394'>
-<a href='https://www.blogger.com/post-edit.g?blogID=7620301364506750761&postID=4739099319381019739&from=pencil' title='Edit Post'>
-<img alt='' class='icon-action' height='18' src='https://resources.blogblog.com/img/icon18_edit_allbkg.gif' width='18'/>
-</a>
-</span>
-</span>
-</div>
-<div class='post-footer-line post-footer-line-2'><span class='post-labels'>
-Labels:
-<a href='http://www.nowherenearithaca.com/search/label/javascript' rel='tag'>javascript</a>
-</span>
-</div>
-<div class='post-footer-line post-footer-line-3'></div>
-</div>
-</div>
-<script src='https://apis.google.com/js/plusone.js' type='text/javascript'></script>
-<div class='cmt_iframe_holder' data-href='http://www.nowherenearithaca.com/2015/02/javascript-prototype-confusion-and.html' data-viewtype='FILTERED_POSTMOD'></div>
-</div>
-
-        </div></div>
-      
-</div>
-<div class='blog-pager' id='blog-pager'>
-<span id='blog-pager-newer-link'>
-<a class='blog-pager-newer-link' href='http://www.nowherenearithaca.com/2015/02/are-symbols-in-es6-worth-weight.html' id='Blog1_blog-pager-newer-link' title='Newer Post'>Newer Post</a>
-</span>
-<span id='blog-pager-older-link'>
-<a class='blog-pager-older-link' href='http://www.nowherenearithaca.com/2015/01/animating-family-trees-la-pachinko.html' id='Blog1_blog-pager-older-link' title='Older Post'>Older Post</a>
-</span>
-<a class='home-link' href='http://www.nowherenearithaca.com/'>Home</a>
-</div>
-<div class='clear'></div>
-<div class='post-feeds'>
-<div class='feed-links'>
-Subscribe to:
-<a class='feed-link' href='http://www.nowherenearithaca.com/feeds/4739099319381019739/comments/default' target='_blank' type='application/atom+xml'>Post Comments (Atom)</a>
-</div>
-</div>
-<script type="text/javascript">window.___gcfg = {'lang': 'en'};</script>
-</div><div class='widget PopularPosts' data-version='1' id='PopularPosts1'>
-<h2>Popular Posts</h2>
-<div class='widget-content popular-posts'>
-<ul>
-<li>
-<div class='item-content'>
-<div class='item-thumbnail'>
-<a href='http://www.nowherenearithaca.com/2012/12/simulating-us-birthsdeaths-in-real-time.html' target='_blank'>
-<img alt='' border='0' src='http://4.bp.blogspot.com/--FlFNxOuXB4/VBxaQxKqE4I/AAAAAAAACPQ/jhzjBxnSHHQ/w72-h72-p-nu/Screen%2BShot%2B2014-09-19%2Bat%2B12.27.26%2BPM.png'/>
-</a>
-</div>
-<div class='item-title'><a href='http://www.nowherenearithaca.com/2012/12/simulating-us-birthsdeaths-in-real-time.html'>Simulating US Births/Deaths in Real-Time - a D3 Visualization</a></div>
-<div class='item-snippet'> Note: I have extended this to a visualization for the entire world, which is on googledrive here .   Recently, I was wondering how what it ...</div>
-</div>
-<div style='clear: both;'></div>
-</li>
-<li>
-<div class='item-content'>
-<div class='item-thumbnail'>
-<a href='http://www.nowherenearithaca.com/2014/02/a-summary-of-some-of-my-visualizations.html' target='_blank'>
-<img alt='' border='0' src='http://2.bp.blogspot.com/-c1yaJ-Jo9sY/Uwi4WM7omZI/AAAAAAAABh0/NwP5TWroB_A/w72-h72-p-nu/Screen+Shot+2014-02-22+at+9.26.49+AM.png'/>
-</a>
-</div>
-<div class='item-title'><a href='http://www.nowherenearithaca.com/2014/02/a-summary-of-some-of-my-visualizations.html'>A Summary of Some of My Visualizations</a></div>
-<div class='item-snippet'>     The purpose of this page is to summarize in one place some of the interactive visualizations I have worked on. Most of these were built...</div>
-</div>
-<div style='clear: both;'></div>
-</li>
-</ul>
-<div class='clear'></div>
-<span class='widget-item-control'>
-<span class='item-control blog-admin'>
-<a class='quickedit' href='//www.blogger.com/rearrange?blogID=7620301364506750761&widgetType=PopularPosts&widgetId=PopularPosts1&action=editWidget&sectionId=main' onclick='return _WidgetManager._PopupConfig(document.getElementById("PopularPosts1"));' target='configPopularPosts1' title='Edit'>
-<img alt='' height='18' src='https://resources.blogblog.com/img/icon18_wrench_allbkg.png' width='18'/>
-</a>
-</span>
-</span>
-<div class='clear'></div>
-</div>
-</div></div>
-</div>
-</div>
-<div class='column-left-outer'>
-<div class='column-left-inner'>
-<aside>
-</aside>
-</div>
-</div>
-<div class='column-right-outer'>
-<div class='column-right-inner'>
-<aside>
-<div class='sidebar section' id='sidebar-right-1'><div class='widget Text' data-version='1' id='Text2'>
-<div class='widget-content'>
-<span  iclass="Apple-style-span"  style="icolor: rgb(34, 34, 34); line-height: 16px;font-family:Georgia, Utopia, 'palatino linotype', Palatino, serif;font-size:12px;">"When you start on your journey to Ithaca, then pray that the road is long, full of adventure, full of knowledge... Always keep Ithaca fixed in your mind. To arrive there is your ultimate goal. But do not hurry the voyage at all." (from "Ithaca", by C. P. Cavafy)</span>
-</div>
-<div class='clear'></div>
-<span class='widget-item-control'>
-<span class='item-control blog-admin'>
-<a class='quickedit' href='//www.blogger.com/rearrange?blogID=7620301364506750761&widgetType=Text&widgetId=Text2&action=editWidget&sectionId=sidebar-right-1' onclick='return _WidgetManager._PopupConfig(document.getElementById("Text2"));' target='configText2' title='Edit'>
-<img alt='' height='18' src='https://resources.blogblog.com/img/icon18_wrench_allbkg.png' width='18'/>
-</a>
-</span>
-</span>
-<div class='clear'></div>
-</div><div class='widget Label' data-version='1' id='Label1'>
-<h2>Labels</h2>
-<div class='widget-content list-label-widget-content'>
-<ul>
-<li>
-<a dir='ltr' href='http://www.nowherenearithaca.com/search/label/d3'>d3</a>
-<span dir='ltr'>(59)</span>
-</li>
-<li>
-<a dir='ltr' href='http://www.nowherenearithaca.com/search/label/javascript'>javascript</a>
-<span dir='ltr'>(30)</span>
-</li>
-<li>
-<a dir='ltr' href='http://www.nowherenearithaca.com/search/label/Exploring...'>Exploring...</a>
-<span dir='ltr'>(16)</span>
-</li>
-<li>
-<a dir='ltr' href='http://www.nowherenearithaca.com/search/label/algorithms'>algorithms</a>
-<span dir='ltr'>(7)</span>
-</li>
-<li>
-<a dir='ltr' href='http://www.nowherenearithaca.com/search/label/pagerank'>pagerank</a>
-<span dir='ltr'>(5)</span>
-</li>
-<li>
-<a dir='ltr' href='http://www.nowherenearithaca.com/search/label/quicksort'>quicksort</a>
-<span dir='ltr'>(4)</span>
-</li>
-<li>
-<a dir='ltr' href='http://www.nowherenearithaca.com/search/label/design'>design</a>
-<span dir='ltr'>(3)</span>
-</li>
-<li>
-<a dir='ltr' href='http://www.nowherenearithaca.com/search/label/bigrams'>bigrams</a>
-<span dir='ltr'>(2)</span>
-</li>
-<li>
-<a dir='ltr' href='http://www.nowherenearithaca.com/search/label/Summary'>Summary</a>
-<span dir='ltr'>(1)</span>
-</li>
-</ul>
-<div class='clear'></div>
-<span class='widget-item-control'>
-<span class='item-control blog-admin'>
-<a class='quickedit' href='//www.blogger.com/rearrange?blogID=7620301364506750761&widgetType=Label&widgetId=Label1&action=editWidget&sectionId=sidebar-right-1' onclick='return _WidgetManager._PopupConfig(document.getElementById("Label1"));' target='configLabel1' title='Edit'>
-<img alt='' height='18' src='https://resources.blogblog.com/img/icon18_wrench_allbkg.png' width='18'/>
-</a>
-</span>
-</span>
-<div class='clear'></div>
-</div>
-</div></div>
-</aside>
-</div>
-</div>
-</div>
-<div style='clear: both'></div>
-<!-- columns -->
-</div>
-<!-- main -->
-</div>
-</div>
-<div class='main-cap-bottom cap-bottom'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-</div>
-<footer>
-<div class='footer-outer'>
-<div class='footer-cap-top cap-top'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-<div class='fauxborder-left footer-fauxborder-left'>
-<div class='fauxborder-right footer-fauxborder-right'></div>
-<div class='region-inner footer-inner'>
-<div class='foot no-items section' id='footer-1'></div>
-<table border='0' cellpadding='0' cellspacing='0' class='section-columns columns-2'>
-<tbody>
-<tr>
-<td class='first columns-cell'>
-<div class='foot no-items section' id='footer-2-1'></div>
-</td>
-<td class='columns-cell'>
-<div class='foot no-items section' id='footer-2-2'></div>
-</td>
-</tr>
-</tbody>
-</table>
-<!-- outside of the include in order to lock Attribution widget -->
-<div class='foot no-items section' id='footer-3'></div>
-</div>
-</div>
-<div class='footer-cap-bottom cap-bottom'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-</div>
-</footer>
-<!-- content -->
-</div>
-</div>
-<div class='content-cap-bottom cap-bottom'>
-<div class='cap-left'></div>
-<div class='cap-right'></div>
-</div>
-</div>
-</div>
-<script type='text/javascript'>
-    window.setTimeout(function() {
-        document.body.className = document.body.className.replace('loading', '');
-      }, 10);
-  </script>
-<script type='text/javascript'>
-        let _gaq = _gaq || [];
-        _gaq.push(['_setAccount', 'UA-38095489-1']);
-        _gaq.push(['_trackPageview']);
-        (function() {
-          let ga = document.createElement('script');
-          ga.type = 'text/javascript';
-          ga.async = true;
-          ga.src = (document.location.protocol == 'https:' ?
-                    'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
-          let s = document.getElementsByTagName('script')[0];
-          s.parentNode.insertBefore(ga, s);
-        })();
-      </script>
-<script>
-//<![CDATA[
-window['PR_SHOULD_USE_CONTINUATION']=true;let prettyPrintOne;let prettyPrint;(function(){let win=window;let FLOW_CONTROL_KEYWORDS=["break,continue,do,else,for,if,return,while"];let C_KEYWORDS=[FLOW_CONTROL_KEYWORDS,"auto,case,char,const,default,"+"double,enum,extern,float,goto,int,long,register,short,signed,sizeof,"+"static,struct,switch,typedef,union,unsigned,void,volatile"];let COMMON_KEYWORDS=[C_KEYWORDS,"catch,class,delete,false,import,"+"new,operator,private,protected,public,this,throw,true,try,typeof"];let CPP_KEYWORDS=[COMMON_KEYWORDS,"alignof,align_union,asm,axiom,bool,"+"concept,concept_map,const_cast,constexpr,decltype,"+"dynamic_cast,explicit,export,friend,inline,late_check,"+"mutable,namespace,nullptr,reinterpret_cast,static_assert,static_cast,"+"template,typeid,typename,using,virtual,where"];let JAVA_KEYWORDS=[COMMON_KEYWORDS,"abstract,boolean,byte,extends,final,finally,implements,import,"+"instanceof,null,native,package,strictfp,super,synchronized,throws,"+"transient"];let CSHARP_KEYWORDS=[JAVA_KEYWORDS,"as,base,by,checked,decimal,delegate,descending,dynamic,event,"+"fixed,foreach,from,group,implicit,in,interface,internal,into,is,let,"+"lock,object,out,override,orderby,params,partial,readonly,ref,sbyte,"+"sealed,stackalloc,string,select,uint,ulong,unchecked,unsafe,ushort,"+"var,virtual,where"];let COFFEE_KEYWORDS="all,and,by,catch,class,else,extends,false,finally,"+"for,if,in,is,isnt,loop,new,no,not,null,of,off,on,or,return,super,then,"+"throw,true,try,unless,until,when,while,yes";let JSCRIPT_KEYWORDS=[COMMON_KEYWORDS,"debugger,eval,export,function,get,null,set,undefined,var,with,"+"Infinity,NaN"];let PERL_KEYWORDS="caller,delete,die,do,dump,elsif,eval,exit,foreach,for,"+"goto,if,import,last,local,my,next,no,our,print,package,redo,require,"+"sub,undef,unless,until,use,wantarray,while,BEGIN,END";let PYTHON_KEYWORDS=[FLOW_CONTROL_KEYWORDS,"and,as,assert,class,def,del,"+"elif,except,exec,finally,from,global,import,in,is,lambda,"+"nonlocal,not,or,pass,print,raise,try,with,yield,"+"False,True,None"];let RUBY_KEYWORDS=[FLOW_CONTROL_KEYWORDS,"alias,and,begin,case,class,"+"def,defined,elsif,end,ensure,false,in,module,next,nil,not,or,redo,"+"rescue,retry,self,super,then,true,undef,unless,until,when,yield,"+"BEGIN,END"];let SH_KEYWORDS=[FLOW_CONTROL_KEYWORDS,"case,done,elif,esac,eval,fi,"+"function,in,local,set,then,until"];let ALL_KEYWORDS=[CPP_KEYWORDS,CSHARP_KEYWORDS,JSCRIPT_KEYWORDS,PERL_KEYWORDS+PYTHON_KEYWORDS,RUBY_KEYWORDS,SH_KEYWORDS];let C_TYPES=/^(DIR|FILE|vector|(de|priority_)?queue|list|stack|(const_)?iterator|(multi)?(set|map)|bitset|u?(int|float)\d*)\b/;let PR_STRING='str';let PR_KEYWORD='kwd';let PR_COMMENT='com';let PR_TYPE='typ';let PR_LITERAL='lit';let PR_PUNCTUATION='pun';let PR_PLAIN='pln';let PR_TAG='tag';let PR_DECLARATION='dec';let PR_SOURCE='src';let PR_ATTRIB_NAME='atn';let PR_ATTRIB_VALUE='atv';let PR_NOCODE='nocode';let REGEXP_PRECEDER_PATTERN='(?:^^\\.?|[+-]|[!=]=?=?|\\#|%=?|&&?=?|\\(|\\*=?|[+\\-]=|->|\\/=?|::?|<<?=?|>>?>?=?|,|;|\\?|@|\\[|~|{|\\^\\^?=?|\\|\\|?=?|break|case|continue|delete|do|else|finally|instanceof|return|throw|try|typeof)\\s*';function combinePrefixPatterns(regexs){let capturedGroupIndex=0;let needToFoldCase=false;let ignoreCase=false;for(let i=0,n=regexs.length;i<n;++i){let regex=regexs[i];if(regex.ignoreCase){ignoreCase=true}else if(/[a-z]/i.test(regex.source.replace(/\\u[0-9a-f]{4}|\\x[0-9a-f]{2}|\\[^ux]/gi,''))){needToFoldCase=true;ignoreCase=false;break}}let escapeCharToCodeUnit={'b':8,'t':9,'n':0xa,'v':0xb,'f':0xc,'r':0xd};function decodeEscape(charsetPart){let cc0=charsetPart.charCodeAt(0);if(cc0!==92){return cc0}let c1=charsetPart.charAt(1);cc0=escapeCharToCodeUnit[c1];if(cc0){return cc0}else if('0'<=c1&&c1<='7'){return parseInt(charsetPart.substring(1),8)}else if(c1==='u'||c1==='x'){return parseInt(charsetPart.substring(2),16)}else{return charsetPart.charCodeAt(1)}}function encodeEscape(charCode){if(charCode<0x20){return(charCode<0x10?'\\x0':'\\x')+charCode.toString(16)}let ch=String.fromCharCode(charCode);return(ch==='\\'||ch==='-'||ch===']'||ch==='^')?"\\"+ch:ch}function caseFoldCharset(charSet){let charsetParts=charSet.substring(1,charSet.length-1).match(new RegExp('\\\\u[0-9A-Fa-f]{4}'+'|\\\\x[0-9A-Fa-f]{2}'+'|\\\\[0-3][0-7]{0,2}'+'|\\\\[0-7]{1,2}'+'|\\\\[\\s\\S]'+'|-'+'|[^-\\\\]','g'));let ranges=[];let inverse=charsetParts[0]==='^';let out=['['];if(inverse){out.push('^')}for(let i=inverse?1:0,n=charsetParts.length;i<n;++i){let p=charsetParts[i];if(/\\[bdsw]/i.test(p)){out.push(p)}else{let start=decodeEscape(p);let end;if(i+2<n&&'-'===charsetParts[i+1]){end=decodeEscape(charsetParts[i+2]);i+=2}else{end=start}ranges.push([start,end]);if(!(end<65||start>122)){if(!(end<65||start>90)){ranges.push([Math.max(65,start)|32,Math.min(end,90)|32])}if(!(end<97||start>122)){ranges.push([Math.max(97,start)&~32,Math.min(end,122)&~32])}}}}ranges.sort(function(a,b){return(a[0]-b[0])||(b[1]-a[1])});let consolidatedRanges=[];let lastRange=[];for(let i=0;i<ranges.length;++i){let range=ranges[i];if(range[0]<=lastRange[1]+1){lastRange[1]=Math.max(lastRange[1],range[1])}else{consolidatedRanges.push(lastRange=range)}}for(let i=0;i<consolidatedRanges.length;++i){let range=consolidatedRanges[i];out.push(encodeEscape(range[0]));if(range[1]>range[0]){if(range[1]+1>range[0]){out.push('-')}out.push(encodeEscape(range[1]))}}out.push(']');return out.join('')}function allowAnywhereFoldCaseAndRenumberGroups(regex){let parts=regex.source.match(new RegExp('(?:'+'\\[(?:[^\\x5C\\x5D]|\\\\[\\s\\S])*\\]'+'|\\\\u[A-Fa-f0-9]{4}'+'|\\\\x[A-Fa-f0-9]{2}'+'|\\\\[0-9]+'+'|\\\\[^ux0-9]'+'|\\(\\?[:!=]'+'|[\\(\\)\\^]'+'|[^\\x5B\\x5C\\(\\)\\^]+'+')','g'));let n=parts.length;let capturedGroups=[];for(let i=0,groupIndex=0;i<n;++i){let p=parts[i];if(p==='('){++groupIndex}else if('\\'===p.charAt(0)){let decimalValue=+p.substring(1);if(decimalValue){if(decimalValue<=groupIndex){capturedGroups[decimalValue]=-1}else{parts[i]=encodeEscape(decimalValue)}}}}for(let i=1;i<capturedGroups.length;++i){if(-1===capturedGroups[i]){capturedGroups[i]=++capturedGroupIndex}}for(let i=0,groupIndex=0;i<n;++i){let p=parts[i];if(p==='('){++groupIndex;if(!capturedGroups[groupIndex]){parts[i]='(?:'}}else if('\\'===p.charAt(0)){let decimalValue=+p.substring(1);if(decimalValue&&decimalValue<=groupIndex){parts[i]='\\'+capturedGroups[decimalValue]}}}for(let i=0;i<n;++i){if('^'===parts[i]&&'^'!==parts[i+1]){parts[i]=''}}if(regex.ignoreCase&&needToFoldCase){for(let i=0;i<n;++i){let p=parts[i];let ch0=p.charAt(0);if(p.length>=2&&ch0==='['){parts[i]=caseFoldCharset(p)}else if(ch0!=='\\'){parts[i]=p.replace(/[a-zA-Z]/g,function(ch){let cc=ch.charCodeAt(0);return'['+String.fromCharCode(cc&~32,cc|32)+']'})}}}return parts.join('')}let rewritten=[];for(let i=0,n=regexs.length;i<n;++i){let regex=regexs[i];if(regex.global||regex.multiline){throw new Error(''+regex);}rewritten.push('(?:'+allowAnywhereFoldCaseAndRenumberGroups(regex)+')')}return new RegExp(rewritten.join('|'),ignoreCase?'gi':'g')}function extractSourceSpans(node,isPreformatted){let nocode=/(?:^|\s)nocode(?:\s|$)/;let chunks=[];let length=0;let spans=[];let k=0;function walk(node){switch(node.nodeType){case 1:if(nocode.test(node.className)){return}for(let child=node.firstChild;child;child=child.nextSibling){walk(child)}let nodeName=node.nodeName.toLowerCase();if('br'===nodeName||'li'===nodeName){chunks[k]='\n';spans[k<<1]=length++;spans[(k++<<1)|1]=node}break;case 3:case 4:let text=node.nodeValue;if(text.length){if(!isPreformatted){text=text.replace(/[ \t\r\n]+/g,' ')}else{text=text.replace(/\r\n?/g,'\n')}chunks[k]=text;spans[k<<1]=length;length+=text.length;spans[(k++<<1)|1]=node}break}}walk(node);return{sourceCode:chunks.join('').replace(/\n$/,''),spans:spans}}function appendDecorations(basePos,sourceCode,langHandler,out){if(!sourceCode){return}let job={sourceCode:sourceCode,basePos:basePos};langHandler(job);out.push.apply(out,job.decorations)}let notWs=/\S/;function childContentWrapper(element){let wrapper=undefined;for(let c=element.firstChild;c;c=c.nextSibling){let type=c.nodeType;wrapper=(type===1)?(wrapper?element:c):(type===3)?(notWs.test(c.nodeValue)?element:wrapper):wrapper}return wrapper===element?undefined:wrapper}function createSimpleLexer(shortcutStylePatterns,fallthroughStylePatterns){let shortcuts={};let tokenizer;(function(){let allPatterns=shortcutStylePatterns.concat(fallthroughStylePatterns);let allRegexs=[];let regexKeys={};for(let i=0,n=allPatterns.length;i<n;++i){let patternParts=allPatterns[i];let shortcutChars=patternParts[3];if(shortcutChars){for(let c=shortcutChars.length;--c>=0;){shortcuts[shortcutChars.charAt(c)]=patternParts}}let regex=patternParts[1];let k=''+regex;if(!regexKeys.hasOwnProperty(k)){allRegexs.push(regex);regexKeys[k]=null}}allRegexs.push(/[\0-\uffff]/);tokenizer=combinePrefixPatterns(allRegexs)})();let nPatterns=fallthroughStylePatterns.length;let decorate=function(job){let sourceCode=job.sourceCode,basePos=job.basePos;let decorations=[basePos,PR_PLAIN];let pos=0;let tokens=sourceCode.match(tokenizer)||[];let styleCache={};for(let ti=0,nTokens=tokens.length;ti<nTokens;++ti){let token=tokens[ti];let style=styleCache[token];let match=void 0;let isEmbedded;if(typeof style==='string'){isEmbedded=false}else{let patternParts=shortcuts[token.charAt(0)];if(patternParts){match=token.match(patternParts[1]);style=patternParts[0]}else{for(let i=0;i<nPatterns;++i){patternParts=fallthroughStylePatterns[i];match=token.match(patternParts[1]);if(match){style=patternParts[0];break}}if(!match){style=PR_PLAIN}}isEmbedded=style.length>=5&&'lang-'===style.substring(0,5);if(isEmbedded&&!(match&&typeof match[1]==='string')){isEmbedded=false;style=PR_SOURCE}if(!isEmbedded){styleCache[token]=style}}let tokenStart=pos;pos+=token.length;if(!isEmbedded){decorations.push(basePos+tokenStart,style)}else{let embeddedSource=match[1];let embeddedSourceStart=token.indexOf(embeddedSource);let embeddedSourceEnd=embeddedSourceStart+embeddedSource.length;if(match[2]){embeddedSourceEnd=token.length-match[2].length;embeddedSourceStart=embeddedSourceEnd-embeddedSource.length}let lang=style.substring(5);appendDecorations(basePos+tokenStart,token.substring(0,embeddedSourceStart),decorate,decorations);appendDecorations(basePos+tokenStart+embeddedSourceStart,embeddedSource,langHandlerForExtension(lang,embeddedSource),decorations);appendDecorations(basePos+tokenStart+embeddedSourceEnd,token.substring(embeddedSourceEnd),decorate,decorations)}}job.decorations=decorations};return decorate}function sourceDecorator(options){let shortcutStylePatterns=[],fallthroughStylePatterns=[];if(options['tripleQuotedStrings']){shortcutStylePatterns.push([PR_STRING,/^(?:\'\'\'(?:[^\'\\]|\\[\s\S]|\'{1,2}(?=[^\']))*(?:\'\'\'|$)|\"\"\"(?:[^\"\\]|\\[\s\S]|\"{1,2}(?=[^\"]))*(?:\"\"\"|$)|\'(?:[^\\\']|\\[\s\S])*(?:\'|$)|\"(?:[^\\\"]|\\[\s\S])*(?:\"|$))/,null,'\'"'])}else if(options['multiLineStrings']){shortcutStylePatterns.push([PR_STRING,/^(?:\'(?:[^\\\']|\\[\s\S])*(?:\'|$)|\"(?:[^\\\"]|\\[\s\S])*(?:\"|$)|\`(?:[^\\\`]|\\[\s\S])*(?:\`|$))/,null,'\'"`'])}else{shortcutStylePatterns.push([PR_STRING,/^(?:\'(?:[^\\\'\r\n]|\\.)*(?:\'|$)|\"(?:[^\\\"\r\n]|\\.)*(?:\"|$))/,null,'"\''])}if(options['verbatimStrings']){fallthroughStylePatterns.push([PR_STRING,/^@\"(?:[^\"]|\"\")*(?:\"|$)/,null])}let hc=options['hashComments'];if(hc){if(options['cStyleComments']){if(hc>1){shortcutStylePatterns.push([PR_COMMENT,/^#(?:##(?:[^#]|#(?!##))*(?:###|$)|.*)/,null,'#'])}else{shortcutStylePatterns.push([PR_COMMENT,/^#(?:(?:define|e(?:l|nd)if|else|error|ifn?def|include|line|pragma|undef|warning)\b|[^\r\n]*)/,null,'#'])}fallthroughStylePatterns.push([PR_STRING,/^<(?:(?:(?:\.\.\/)*|\/?)(?:[\w-]+(?:\/[\w-]+)+)?[\w-]+\.h(?:h|pp|\+\+)?|[a-z]\w*)>/,null])}else{shortcutStylePatterns.push([PR_COMMENT,/^#[^\r\n]*/,null,'#'])}}if(options['cStyleComments']){fallthroughStylePatterns.push([PR_COMMENT,/^\/\/[^\r\n]*/,null]);fallthroughStylePatterns.push([PR_COMMENT,/^\/\*[\s\S]*?(?:\*\/|$)/,null])}if(options['regexLiterals']){let REGEX_LITERAL=('/(?=[^/*])'+'(?:[^/\\x5B\\x5C]'+'|\\x5C[\\s\\S]'+'|\\x5B(?:[^\\x5C\\x5D]|\\x5C[\\s\\S])*(?:\\x5D|$))+'+'/');fallthroughStylePatterns.push(['lang-regex',new RegExp('^'+REGEXP_PRECEDER_PATTERN+'('+REGEX_LITERAL+')')])}let types=options['types'];if(types){fallthroughStylePatterns.push([PR_TYPE,types])}let keywords=(""+options['keywords']).replace(/^ | $/g,'');if(keywords.length){fallthroughStylePatterns.push([PR_KEYWORD,new RegExp('^(?:'+keywords.replace(/[\s,]+/g,'|')+')\\b'),null])}shortcutStylePatterns.push([PR_PLAIN,/^\s+/,null,' \r\n\t\xA0']);let punctuation=/^.[^\s\w\.$@\'\"\`\/\\]*/;fallthroughStylePatterns.push([PR_LITERAL,/^@[a-z_$][a-z_$@0-9]*/i,null],[PR_TYPE,/^(?:[@_]?[A-Z]+[a-z][A-Za-z_$@0-9]*|\w+_t\b)/,null],[PR_PLAIN,/^[a-z_$][a-z_$@0-9]*/i,null],[PR_LITERAL,new RegExp('^(?:'+'0x[a-f0-9]+'+'|(?:\\d(?:_\\d+)*\\d*(?:\\.\\d*)?|\\.\\d\\+)'+'(?:e[+\\-]?\\d+)?'+')'+'[a-z]*','i'),null,'0123456789'],[PR_PLAIN,/^\\[\s\S]?/,null],[PR_PUNCTUATION,punctuation,null]);return createSimpleLexer(shortcutStylePatterns,fallthroughStylePatterns)}let decorateSource=sourceDecorator({'keywords':ALL_KEYWORDS,'hashComments':true,'cStyleComments':true,'multiLineStrings':true,'regexLiterals':true});function numberLines(node,opt_startLineNum,isPreformatted){let nocode=/(?:^|\s)nocode(?:\s|$)/;let lineBreak=/\r\n?|\n/;let document=node.ownerDocument;let li=document.createElement('li');while(node.firstChild){li.appendChild(node.firstChild)}let listItems=[li];function walk(node){switch(node.nodeType){case 1:if(nocode.test(node.className)){break}if('br'===node.nodeName){breakAfter(node);if(node.parentNode){node.parentNode.removeChild(node)}}else{for(let child=node.firstChild;child;child=child.nextSibling){walk(child)}}break;case 3:case 4:if(isPreformatted){let text=node.nodeValue;let match=text.match(lineBreak);if(match){let firstLine=text.substring(0,match.index);node.nodeValue=firstLine;let tail=text.substring(match.index+match[0].length);if(tail){let parent=node.parentNode;parent.insertBefore(document.createTextNode(tail),node.nextSibling)}breakAfter(node);if(!firstLine){node.parentNode.removeChild(node)}}}break}}function breakAfter(lineEndNode){while(!lineEndNode.nextSibling){lineEndNode=lineEndNode.parentNode;if(!lineEndNode){return}}function breakLeftOf(limit,copy){let rightSide=copy?limit.cloneNode(false):limit;let parent=limit.parentNode;if(parent){let parentClone=breakLeftOf(parent,1);let next=limit.nextSibling;parentClone.appendChild(rightSide);for(let sibling=next;sibling;sibling=next){next=sibling.nextSibling;parentClone.appendChild(sibling)}}return rightSide}let copiedListItem=breakLeftOf(lineEndNode.nextSibling,0);for(let parent;(parent=copiedListItem.parentNode)&&parent.nodeType===1;){copiedListItem=parent}listItems.push(copiedListItem)}for(let i=0;i<listItems.length;++i){walk(listItems[i])}if(opt_startLineNum===(opt_startLineNum|0)){listItems[0].setAttribute('value',opt_startLineNum)}let ol=document.createElement('ol');ol.className='linenums';let offset=Math.max(0,((opt_startLineNum-1))|0)||0;for(let i=0,n=listItems.length;i<n;++i){li=listItems[i];li.className='L'+((i+offset)%10);if(!li.firstChild){li.appendChild(document.createTextNode('\xA0'))}ol.appendChild(li)}node.appendChild(ol)}function recombineTagsAndDecorations(job){let isIE8OrEarlier=/\bMSIE\s(\d+)/.exec(navigator.userAgent);isIE8OrEarlier=isIE8OrEarlier&&+isIE8OrEarlier[1]<=8;let newlineRe=/\n/g;let source=job.sourceCode;let sourceLength=source.length;let sourceIndex=0;let spans=job.spans;let nSpans=spans.length;let spanIndex=0;let decorations=job.decorations;let nDecorations=decorations.length;let decorationIndex=0;decorations[nDecorations]=sourceLength;let decPos,i;for(i=decPos=0;i<nDecorations;){if(decorations[i]!==decorations[i+2]){decorations[decPos++]=decorations[i++];decorations[decPos++]=decorations[i++]}else{i+=2}}nDecorations=decPos;for(i=decPos=0;i<nDecorations;){let startPos=decorations[i];let startDec=decorations[i+1];let end=i+2;while(end+2<=nDecorations&&decorations[end+1]===startDec){end+=2}decorations[decPos++]=startPos;decorations[decPos++]=startDec;i=end}nDecorations=decorations.length=decPos;let sourceNode=job.sourceNode;let oldDisplay;if(sourceNode){oldDisplay=sourceNode.style.display;sourceNode.style.display='none'}try{let decoration=null;while(spanIndex<nSpans){let spanStart=spans[spanIndex];let spanEnd=spans[spanIndex+2]||sourceLength;let decEnd=decorations[decorationIndex+2]||sourceLength;let end=Math.min(spanEnd,decEnd);let textNode=spans[spanIndex+1];let styledText;if(textNode.nodeType!==1&&(styledText=source.substring(sourceIndex,end))){if(isIE8OrEarlier){styledText=styledText.replace(newlineRe,'\r')}textNode.nodeValue=styledText;let document=textNode.ownerDocument;let span=document.createElement('span');span.className=decorations[decorationIndex+1];let parentNode=textNode.parentNode;parentNode.replaceChild(span,textNode);span.appendChild(textNode);if(sourceIndex<spanEnd){spans[spanIndex+1]=textNode=document.createTextNode(source.substring(end,spanEnd));parentNode.insertBefore(textNode,span.nextSibling)}}sourceIndex=end;if(sourceIndex>=spanEnd){spanIndex+=2}if(sourceIndex>=decEnd){decorationIndex+=2}}}finally{if(sourceNode){sourceNode.style.display=oldDisplay}}}let langHandlerRegistry={};function registerLangHandler(handler,fileExtensions){for(let i=fileExtensions.length;--i>=0;){let ext=fileExtensions[i];if(!langHandlerRegistry.hasOwnProperty(ext)){langHandlerRegistry[ext]=handler}else if(win['console']){console['warn']('cannot override language handler %s',ext)}}}function langHandlerForExtension(extension,source){if(!(extension&&langHandlerRegistry.hasOwnProperty(extension))){extension=/^\s*</.test(source)?'default-markup':'default-code'}return langHandlerRegistry[extension]}registerLangHandler(decorateSource,['default-code']);registerLangHandler(createSimpleLexer([],[[PR_PLAIN,/^[^<?]+/],[PR_DECLARATION,/^<!\w[^>]*(?:>|$)/],[PR_COMMENT,/^<\!--[\s\S]*?(?:-\->|$)/],['lang-',/^<\?([\s\S]+?)(?:\?>|$)/],['lang-',/^<%([\s\S]+?)(?:%>|$)/],[PR_PUNCTUATION,/^(?:<[%?]|[%?]>)/],['lang-',/^<xmp\b[^>]*>([\s\S]+?)<\/xmp\b[^>]*>/i],['lang-js',/^<script\b[^>]*>([\s\S]*?)(<\/script\b[^>]*>)/i],['lang-css',/^<style\b[^>]*>([\s\S]*?)(<\/style\b[^>]*>)/i],['lang-in.tag',/^(<\/?[a-z][^<>]*>)/i]]),['default-markup','htm','html','mxml','xhtml','xml','xsl']);registerLangHandler(createSimpleLexer([[PR_PLAIN,/^[\s]+/,null,' \t\r\n'],[PR_ATTRIB_VALUE,/^(?:\"[^\"]*\"?|\'[^\']*\'?)/,null,'\"\'']],[[PR_TAG,/^^<\/?[a-z](?:[\w.:-]*\w)?|\/?>$/i],[PR_ATTRIB_NAME,/^(?!style[\s=]|on)[a-z](?:[\w:-]*\w)?/i],['lang-uq.val',/^=\s*([^>\'\"\s]*(?:[^>\'\"\s\/]|\/(?=\s)))/],[PR_PUNCTUATION,/^[=<>\/]+/],['lang-js',/^on\w+\s*=\s*\"([^\"]+)\"/i],['lang-js',/^on\w+\s*=\s*\'([^\']+)\'/i],['lang-js',/^on\w+\s*=\s*([^\"\'>\s]+)/i],['lang-css',/^style\s*=\s*\"([^\"]+)\"/i],['lang-css',/^style\s*=\s*\'([^\']+)\'/i],['lang-css',/^style\s*=\s*([^\"\'>\s]+)/i]]),['in.tag']);registerLangHandler(createSimpleLexer([],[[PR_ATTRIB_VALUE,/^[\s\S]+/]]),['uq.val']);registerLangHandler(sourceDecorator({'keywords':CPP_KEYWORDS,'hashComments':true,'cStyleComments':true,'types':C_TYPES}),['c','cc','cpp','cxx','cyc','m']);registerLangHandler(sourceDecorator({'keywords':'null,true,false'}),['json']);registerLangHandler(sourceDecorator({'keywords':CSHARP_KEYWORDS,'hashComments':true,'cStyleComments':true,'verbatimStrings':true,'types':C_TYPES}),['cs']);registerLangHandler(sourceDecorator({'keywords':JAVA_KEYWORDS,'cStyleComments':true}),['java']);registerLangHandler(sourceDecorator({'keywords':SH_KEYWORDS,'hashComments':true,'multiLineStrings':true}),['bsh','csh','sh']);registerLangHandler(sourceDecorator({'keywords':PYTHON_KEYWORDS,'hashComments':true,'multiLineStrings':true,'tripleQuotedStrings':true}),['cv','py']);registerLangHandler(sourceDecorator({'keywords':PERL_KEYWORDS,'hashComments':true,'multiLineStrings':true,'regexLiterals':true}),['perl','pl','pm']);registerLangHandler(sourceDecorator({'keywords':RUBY_KEYWORDS,'hashComments':true,'multiLineStrings':true,'regexLiterals':true}),['rb']);registerLangHandler(sourceDecorator({'keywords':JSCRIPT_KEYWORDS,'cStyleComments':true,'regexLiterals':true}),['js']);registerLangHandler(sourceDecorator({'keywords':COFFEE_KEYWORDS,'hashComments':3,'cStyleComments':true,'multilineStrings':true,'tripleQuotedStrings':true,'regexLiterals':true}),['coffee']);registerLangHandler(createSimpleLexer([],[[PR_STRING,/^[\s\S]+/]]),['regex']);function applyDecorator(job){let opt_langExtension=job.langExtension;try{let sourceAndSpans=extractSourceSpans(job.sourceNode,job.pre);let source=sourceAndSpans.sourceCode;job.sourceCode=source;job.spans=sourceAndSpans.spans;job.basePos=0;langHandlerForExtension(opt_langExtension,source)(job);recombineTagsAndDecorations(job)}catch(e){if(win['console']){console['log'](e&&e['stack']?e['stack']:e)}}}function prettyPrintOne(sourceCodeHtml,opt_langExtension,opt_numberLines){let container=document.createElement('pre');container.innerHTML=sourceCodeHtml;if(opt_numberLines){numberLines(container,opt_numberLines,true)}let job={langExtension:opt_langExtension,numberLines:opt_numberLines,sourceNode:container,pre:1};applyDecorator(job);return container.innerHTML}function prettyPrint(opt_whenDone){function byTagName(tn){return document.getElementsByTagName(tn)}let codeSegments=[byTagName('pre'),byTagName('code'),byTagName('xmp')];let elements=[];for(let i=0;i<codeSegments.length;++i){for(let j=0,n=codeSegments[i].length;j<n;++j){elements.push(codeSegments[i][j])}}codeSegments=null;let clock=Date;if(!clock['now']){clock={'now':function(){return+(new Date)}}}let k=0;let prettyPrintingJob;let langExtensionRe=/\blang(?:uage)?-([\w.]+)(?!\S)/;let prettyPrintRe=/\bprettyprint\b/;let prettyPrintedRe=/\bprettyprinted\b/;let preformattedTagNameRe=/pre|xmp/i;let codeRe=/^code$/i;let preCodeXmpRe=/^(?:pre|code|xmp)$/i;function doWork(){let endTime=(win['PR_SHOULD_USE_CONTINUATION']?clock['now']()+250:Infinity);for(;k<elements.length&&clock['now']()<endTime;k++){let cs=elements[k];let className=cs.className;if(prettyPrintRe.test(className)&&!prettyPrintedRe.test(className)){let nested=false;for(let p=cs.parentNode;p;p=p.parentNode){let tn=p.tagName;if(preCodeXmpRe.test(tn)&&p.className&&prettyPrintRe.test(p.className)){nested=true;break}}if(!nested){cs.className+=' prettyprinted';let langExtension=className.match(langExtensionRe);let wrapper;if(!langExtension&&(wrapper=childContentWrapper(cs))&&codeRe.test(wrapper.tagName)){langExtension=wrapper.className.match(langExtensionRe)}if(langExtension){langExtension=langExtension[1]}let preformatted;if(preformattedTagNameRe.test(cs.tagName)){preformatted=1}else{let currentStyle=cs['currentStyle'];let whitespace=(currentStyle?currentStyle['whiteSpace']:(document.defaultView&&document.defaultView.getComputedStyle)?document.defaultView.getComputedStyle(cs,null).getPropertyValue('white-space'):0);preformatted=whitespace&&'pre'===whitespace.substring(0,3)}let lineNums=cs.className.match(/\blinenums\b(?::(\d+))?/);lineNums=lineNums?lineNums[1]&&lineNums[1].length?+lineNums[1]:true:false;if(lineNums){numberLines(cs,lineNums,preformatted)}prettyPrintingJob={langExtension:langExtension,sourceNode:cs,numberLines:lineNums,pre:preformatted};applyDecorator(prettyPrintingJob)}}}if(k<elements.length){setTimeout(doWork,250)}else if(opt_whenDone){opt_whenDone()}}doWork()}let PR=win['PR']={'createSimpleLexer':createSimpleLexer,'registerLangHandler':registerLangHandler,'sourceDecorator':sourceDecorator,'PR_ATTRIB_NAME':PR_ATTRIB_NAME,'PR_ATTRIB_VALUE':PR_ATTRIB_VALUE,'PR_COMMENT':PR_COMMENT,'PR_DECLARATION':PR_DECLARATION,'PR_KEYWORD':PR_KEYWORD,'PR_LITERAL':PR_LITERAL,'PR_NOCODE':PR_NOCODE,'PR_PLAIN':PR_PLAIN,'PR_PUNCTUATION':PR_PUNCTUATION,'PR_SOURCE':PR_SOURCE,'PR_STRING':PR_STRING,'PR_TAG':PR_TAG,'PR_TYPE':PR_TYPE,'prettyPrintOne':win['prettyPrintOne']=prettyPrintOne,'prettyPrint':win['prettyPrint']=prettyPrint};if(typeof define==="function"&&define['amd']){define("google-code-prettify",[],function(){return PR})}})();
-//]]>
-</script>
-<script>
-prettyPrint();
-</script>
-
-
-<!-- 'Αποτελεί δική σας ευθύνη να ενημερώσετε τους επισκέπτες σχετικά με τα cookie που χρησιμοποιούνται στο ιστολόγιο. Ανατρέξτε στη διεύθυνση http://www.blogger.com/go/cookiechoices για περισσότερες λεπτομέρειες.' -->
-<script src="/js/cookiechoices.js" defer></script>
-<script>
-  document.addEventListener('DOMContentLoaded', function(event) {
-    window.cookieChoices && cookieChoices.showCookieConsentBar && cookieChoices.showCookieConsentBar(
-        (window.cookieOptions && cookieOptions.msg) || 'Αυτός ο ιστότοπος χρησιμοποιεί cookie από το Google για την παροχή των υπηρεσιών του, για την εξατομίκευση διαφημίσεων και για την ανάλυση της επισκεψιμότητας. Η Google κοινοποιεί πληροφορίες σχετικά με την από μέρους σας χρήση αυτού του ιστότοπου. Με τη χρήση αυτού του ιστότοπου, αποδέχεστε τη χρήση των cookie.',
-        (window.cookieOptions && cookieOptions.close) || 'Έγινε',
-        (window.cookieOptions && cookieOptions.learn) || 'Μάθετε Περισσότερα',
-        (window.cookieOptions && cookieOptions.link) || 'https://www.blogger.com/go/blogspot-cookies');
-  });
-</script>
-
-<script type="text/javascript" src="https://www.blogger.com/static/v1/widgets/1045850488-widgets.js"></script>
-<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
-<script type='text/javascript'>
-_WidgetManager._Init('//www.blogger.com/rearrange?blogID\x3d7620301364506750761','//www.nowherenearithaca.com/2015/02/javascript-prototype-confusion-and.html','7620301364506750761');
-_WidgetManager._SetDataContext([{'name': 'blog', 'data': {'blogId': '7620301364506750761', 'bloggerUrl': 'https://www.blogger.com', 'title': 'Nowhere Near Ithaca', 'pageType': 'item', 'postId': '4739099319381019739', 'url': 'http://www.nowherenearithaca.com/2015/02/javascript-prototype-confusion-and.html', 'canonicalUrl': 'http://www.nowherenearithaca.com/2015/02/javascript-prototype-confusion-and.html', 'homepageUrl': 'http://www.nowherenearithaca.com/', 'searchUrl': 'http://www.nowherenearithaca.com/search', 'canonicalHomepageUrl': 'http://www.nowherenearithaca.com/', 'blogspotFaviconUrl': 'http://www.nowherenearithaca.com/favicon.ico', 'enabledCommentProfileImages': true, 'adultContent': false, 'analyticsAccountNumber': 'UA-38095489-1', 'useUniversalAnalytics': false, 'pageName': 'Javascript \x22Prototype\x22 Confusion, and the Dubiously Useful \x22instanceof\x22', 'pageTitle': 'Nowhere Near Ithaca: Javascript \x22Prototype\x22 Confusion, and the Dubiously Useful \x22instanceof\x22', 'encoding': 'UTF-8', 'locale': 'en', 'localeUnderscoreDelimited': 'en', 'isPrivate': false, 'isMobile': false, 'isMobileRequest': false, 'mobileClass': '', 'isPrivateBlog': false, 'languageDirection': 'ltr', 'feedLinks': '\x3clink rel\x3d\x22alternate\x22 type\x3d\x22application/atom+xml\x22 title\x3d\x22Nowhere Near Ithaca - Atom\x22 href\x3d\x22http://www.nowherenearithaca.com/feeds/posts/default\x22 /\x3e\n\x3clink rel\x3d\x22alternate\x22 type\x3d\x22application/rss+xml\x22 title\x3d\x22Nowhere Near Ithaca - RSS\x22 href\x3d\x22http://www.nowherenearithaca.com/feeds/posts/default?alt\x3drss\x22 /\x3e\n\x3clink rel\x3d\x22service.post\x22 type\x3d\x22application/atom+xml\x22 title\x3d\x22Nowhere Near Ithaca - Atom\x22 href\x3d\x22https://www.blogger.com/feeds/7620301364506750761/posts/default\x22 /\x3e\n\n\x3clink rel\x3d\x22alternate\x22 type\x3d\x22application/atom+xml\x22 title\x3d\x22Nowhere Near Ithaca - Atom\x22 href\x3d\x22http://www.nowherenearithaca.com/feeds/4739099319381019739/comments/default\x22 /\x3e\n', 'meTag': '', 'openIdOpTag': '', 'postImageThumbnailUrl': 'http://3.bp.blogspot.com/-6DxZ4q1TjVY/VN7J4aym7zI/AAAAAAAACjE/1BpYZ28BG40/s72-c/Screen%2BShot%2B2015-02-13%2Bat%2B11.03.58%2BPM.png', 'postImageUrl': 'http://3.bp.blogspot.com/-6DxZ4q1TjVY/VN7J4aym7zI/AAAAAAAACjE/1BpYZ28BG40/s1600/Screen%2BShot%2B2015-02-13%2Bat%2B11.03.58%2BPM.png', 'mobileHeadScript': '', 'adsenseHostId': 'ca-host-pub-1556223355139109', 'ieCssRetrofitLinks': '\x3c!--[if IE]\x3e\x3cscript type\x3d\x22text/javascript\x22 src\x3d\x22https://www.blogger.com/static/v1/jsbin/1803938243-ieretrofit.js\x22\x3e\x3c/script\x3e\n\x3c![endif]--\x3e', 'view': '', 'dynamicViewsCommentsSrc': '//www.blogblog.com/dynamicviews/4224c15c4e7c9321/js/comments.js', 'dynamicViewsScriptSrc': '//www.blogblog.com/dynamicviews/b1f29a73a8a0bdce', 'plusOneApiSrc': 'https://apis.google.com/js/plusone.js', 'sharing': {'platforms': [{'name': 'Get link', 'key': 'link', 'shareMessage': 'Get link', 'target': ''}, {'name': 'Facebook', 'key': 'facebook', 'shareMessage': 'Share to Facebook', 'target': 'facebook'}, {'name': 'BlogThis!', 'key': 'blogThis', 'shareMessage': 'BlogThis!', 'target': 'blog'}, {'name': 'Twitter', 'key': 'twitter', 'shareMessage': 'Share to Twitter', 'target': 'twitter'}, {'name': 'Pinterest', 'key': 'pinterest', 'shareMessage': 'Share to Pinterest', 'target': 'pinterest'}, {'name': 'Google+', 'key': 'googlePlus', 'shareMessage': 'Share to Google+', 'target': 'googleplus'}, {'name': 'Email', 'key': 'email', 'shareMessage': 'Email', 'target': 'email'}], 'googlePlusShareButtonWidth': 300, 'googlePlusBootstrap': '\x3cscript type\x3d\x22text/javascript\x22\x3ewindow.___gcfg \x3d {\x27lang\x27: \x27en\x27};\x3c/script\x3e'}}}, {'name': 'features', 'data': {'euCookieNotice': true, 'templateBrowserTheme': true, 'widgetVisibility': true}}, {'name': 'messages', 'data': {'adsGoHere': 'Ads go here', 'archive': 'Archive', 'authorSaid': '%1 said...', 'authorSaidWithLink': '\x3ca href\x3d\x22%2\x22 rel\x3d\x22nofollow\x22\x3e%1\x3c/a\x3e said...', 'blogArchive': 'Blog Archive', 'by': 'By', 'byAuthor': 'By %1', 'byAuthorLink': 'By \x3ca href\x3d\x22%2\x22\x3e%1\x3c/a\x3e', 'comments': 'Comments', 'configurationRequired': 'Configuration required', 'deleteBacklink': 'Delete Backlink', 'deleteComment': 'Delete Comment', 'edit': 'Edit', 'euCookieNotice': 'This site uses cookies from Google to deliver its services, to personalize ads and to analyze traffic. Information about your use of this site is shared with Google. By using this site, you agree to its use of cookies.', 'euCookieResponsibility': 'It is your responsibility to notify your visitors about cookies used on your blog. See http://www.blogger.com/go/cookiechoices for more details.', 'emailAddress': 'Email Address', 'getEmailNotifications': 'Get email notifications', 'gotIt': 'Got it', 'hidden': 'Hidden', 'home': 'Home', 'joinTheConversation': 'Join the conversation', 'keepReading': 'Keep reading', 'labels': 'Labels', 'latestPosts': 'Latest Posts', 'learnMore': 'Learn More', 'loadMorePosts': 'Load more posts', 'loading': 'Loading...', 'myBlogList': 'My Blog List', 'myFavoriteSites': 'My favorite sites', 'myPhoto': 'My photo', 'newer': 'Newer', 'newerPosts': 'Newer Posts', 'newest': 'Newest', 'noResultsFound': 'No results found', 'noTitle': 'No title', 'numberOfComments': '{numComments, plural, \x3d0 {No comments} \x3d1 {1 comment} other {# comments}}', 'older': 'Older', 'olderPosts': 'Older Posts', 'oldest': 'Oldest', 'onlyTeamMembersCanComment': 'Note: Only a member of this blog may post a comment.', 'popularPosts': 'Popular Posts', 'popularPostsFromThisBlog': 'Popular posts from this blog', 'postAComment': 'Post a Comment', 'postedBy': 'Posted by', 'postedByAuthor': 'Posted by %1', 'postedByAuthorLink': 'Posted by \x3ca href\x3d\x22%2\x22\x3e%1\x3c/a\x3e', 'readMore': 'Read more', 'recentPosts': 'Recent posts', 'reportAbuse': 'Report Abuse', 'search': 'Search', 'searchBlog': 'Search blog', 'share': 'Share', 'showAll': 'Show all', 'showLess': 'Show less', 'showMore': 'Show more', 'someOfMyFavoriteSites': 'Some of my favorite sites', 'subscribe': 'Subscribe', 'subscribeTo': 'Subscribe to:', 'subscribeToThisBlog': 'Subscribe to this blog', 'theresNothingHere': 'There\x27s nothing here!', 'viewAll': 'View all', 'visible': 'Visible', 'visitProfile': 'Visit profile', 'widgetNotAvailableInPreview': 'This content is not available in blog preview.', 'widgetNotAvailableOnHttps': 'This content is not yet available over encrypted connections.'}}, {'name': 'skin', 'data': {'vars': {'post_footer_background_color': '#f9f9f9', 'tabs_text_color': '#999999', 'content_shadow_spread': '40px', 'date_header_letterspacing': 'inherit', 'body_background_override': '', 'body_background': '#f0f0f0 none repeat scroll top left', 'description_text_size': '140%', 'mobile_background_size': 'auto', 'header_shadow_spread': '1px', 'image_border_color': '#eeeeee', 'date_header_color': '#222222', 'header_shadow_offset_top': '-1px', 'header_border_horizontalsize': '0', 'widget_title_font': 'normal bold 11px Arial, Tahoma, Helvetica, FreeSans, sans-serif', 'tabs_border_color': '#eeeeee', 'tabs_bevel_border_width': '1px', 'body_background_gradient_tile': 'url(http://www.blogblog.com/1kt/simple/body_gradient_tile_light.png)', 'description_text_color': '#777777', 'main_section_margin': '15px', 'post_title_font': 'normal bold 24px Georgia, Utopia, \x27Palatino Linotype\x27, Palatino, serif', 'page_width': 'auto', 'paging_background': 'transparent none no-repeat scroll top center', 'body_text_color': '#222222', 'content_padding': '10px', 'header_background_gradient': 'none', 'post_margin_bottom': '25px', 'header_shadow_offset_left': '-1px', 'tabs_background_color': '#f5f5f5', 'content_background_color': '#ffffff', 'body_background_gradient_cap': 'url(http://www.blogblog.com/1kt/simple/gradients_light.png)', 'main_padding_top': '30px', 'widget_alternate_text_color': '#999999', 'image_text_color': '#222222', 'link_visited_color': '#888888', 'tabs_margin_side': '30px', 'image_border_large_size': '5px', 'content_shadow_spread_webkit': '5px', 'mobile_button_color': '#ffffff', 'tabs_selected_text_color': '#000000', 'main_border_width': '0', 'content_background_color_selector': '.content-inner', 'link_color': '#2288bb', 'post_footer_border_color': '#eeeeee', 'tabs_background_gradient': 'url(http://www.blogblog.com/1kt/simple/gradients_light.png)', 'content_padding_horizontal': '10px', 'header_font': 'italic normal 60px Georgia, Utopia, \x27Palatino Linotype\x27, Palatino, serif', 'startSide': 'left', 'tabs_font': 'normal normal 14px Arial, Tahoma, Helvetica, FreeSans, sans-serif', 'widget_title_text_color': '#000000', 'header_border_size': '1px', 'tabs_selected_background_color': '#eeeeee', 'date_header_margin': 'inherit', 'footer_bevel': '0', 'image_border_small_size': '2px', 'content_shadow_spread_ie': '10px', 'mobile_background_overlay': 'transparent none repeat scroll top left', 'endSide': 'right', 'image_background_color': '#ffffff', 'body_rule_color': '#eeeeee', 'header_bottom_border_size': '1px', 'date_header_padding': 'inherit', 'page_width_selector': '.region-inner', 'body_background_color': '#f0f0f0', 'header_text_color': '#000000', 'main_padding': '15px', 'date_header_background_color': 'transparent', 'tabs_border_width': '1px', 'body_font': 'normal normal 14px Georgia, Utopia, \x27Palatino Linotype\x27, Palatino, serif', 'link_hover_color': '#33aaff', 'header_background_color': 'transparent', 'keycolor': '#66bbdd', 'main_padding_bottom': '30px', 'post_footer_text_color': '#666666', 'tabs_margin_top': '0', 'header_padding': '15px'}, 'override': '.descriptionwrapper {\n  margin-bottom:5px !important;\n}\n\n\n.Header h1 {\n margin-bottom:2px !important;\n}\n\n.titlewrapper {\n line-height:1.01 !important;\npadding-bottom:1px !important;\n}\n\n.main-inner {\n  padding-top:5px !important;\n}\n\n.post-title {\n  margin-top:5px !important;\n}'}}, {'name': 'template', 'data': {'name': 'custom', 'localizedName': 'Custom', 'isResponsive': false, 'isAlternateRendering': false, 'isCustom': true}}, {'name': 'view', 'data': {'classic': {'name': 'classic', 'url': '?view\x3dclassic'}, 'flipcard': {'name': 'flipcard', 'url': '?view\x3dflipcard'}, 'magazine': {'name': 'magazine', 'url': '?view\x3dmagazine'}, 'mosaic': {'name': 'mosaic', 'url': '?view\x3dmosaic'}, 'sidebar': {'name': 'sidebar', 'url': '?view\x3dsidebar'}, 'snapshot': {'name': 'snapshot', 'url': '?view\x3dsnapshot'}, 'timeslide': {'name': 'timeslide', 'url': '?view\x3dtimeslide'}, 'title': 'Javascript \x22Prototype\x22 Confusion, and the Dubiously Useful \x22instanceof\x22', 'description': '             Recently, I became aware that I was more confused than I realized regarding javascript\x26#39;s use of the word \x26quot;prototype\x26qu...', 'featuredImage': 'http://3.bp.blogspot.com/-6DxZ4q1TjVY/VN7J4aym7zI/AAAAAAAACjE/1BpYZ28BG40/s1600/Screen%2BShot%2B2015-02-13%2Bat%2B11.03.58%2BPM.png', 'url': 'http://www.nowherenearithaca.com/2015/02/javascript-prototype-confusion-and.html', 'type': 'item', 'isPage': false, 'isPost': true, 'isHomepage': false, 'isArchive': false, 'isSearch': false, 'postId': 4739099319381019739}}]);
-_WidgetManager._RegisterWidget('_NavbarView', new _WidgetInfo('Navbar1', 'navbar', null, document.getElementById('Navbar1'), {}, 'displayModeFull'));
-_WidgetManager._RegisterWidget('_HeaderView', new _WidgetInfo('Header1', 'header', null, document.getElementById('Header1'), {}, 'displayModeFull'));
-_WidgetManager._RegisterWidget('_BlogView', new _WidgetInfo('Blog1', 'main', null, document.getElementById('Blog1'), {'cmtInteractionsEnabled': false, 'showBacklinks': true, 'postId': '4739099319381019739', 'legacyCommentModerationUrl': 'https://www.blogger.com/moderate-legacy-comment.g?blogID\x3d7620301364506750761', 'iframeCommentsId': 'gpluscomments', 'viewType': 'FILTERED_POSTMOD', 'lightboxEnabled': true, 'lightboxModuleUrl': 'https://www.blogger.com/static/v1/jsbin/2318976799-lbx.js', 'lightboxCssUrl': 'https://www.blogger.com/static/v1/v-css/368954415-lightbox_bundle.css'}, 'displayModeFull'));
-_WidgetManager._RegisterWidget('_PopularPostsView', new _WidgetInfo('PopularPosts1', 'main', null, document.getElementById('PopularPosts1'), {}, 'displayModeFull'));
-_WidgetManager._RegisterWidget('_TextView', new _WidgetInfo('Text2', 'sidebar-right-1', null, document.getElementById('Text2'), {}, 'displayModeFull'));
-_WidgetManager._RegisterWidget('_LabelView', new _WidgetInfo('Label1', 'sidebar-right-1', null, document.getElementById('Label1'), {}, 'displayModeFull'));
-</script>
-</body>
-</html>
\ No newline at end of file
diff --git a/archive/recursion.md b/archive/recursion.md
deleted file mode 100644
index 4b142bd486..0000000000
--- a/archive/recursion.md
+++ /dev/null
@@ -1,283 +0,0 @@
-# Recursion, stack
-
-It's ok for a function to rely on other functions for sub-tasks.
-
-We've already been using it when `welcome()` relied on `alert()` call to show the message.
-
-In particular, a function can make a sub-call *itself*. That's called *a recursion*.
-
-We'll fiddle around that advanced case to better learn how functions work.
-
-[smart header="A topic you already know?"]
-Recursion is a general programming term. If you are already familiar with it, then you may list the page to the next chapter. Please read on if you are new to functions or just prefer not to skip parts.
-[/smart]
-
-## Divide and conquer
-
-Divide and conquer (or "divide and rule") is an ancient strategy attributed to Philip II of Macedon and mentioned by the Roman emperor Julius Caesar, the French emperor Napolen and many other leaders.
-
-They used it to rule, but the similar thing is often done in programming. If we have a complex task, that we're not sure how to solve as a whole, then maybe we can split it and try to solve the smaller parts.
-
-And if smaller parts are still too big, then let's cut them and try to solve even smaller parts. 
-
-Repeat the cutting until the parts are so small that it's obvious how to deal with them.
-
-Sounds good? Now let's explore a case of this approach.
-
-## Eating an elephant
-
-Let's say we have a task "to eat an elephant". But how?
-
-The well-known humorous solution is: "piece by piece". We cut a piece, eat it and repeat the process. Sooner or later, the elephant is eaten.
-
-The algorithm can be reflected in the code:
-
-```
-function eat(elephant) {
-  cut a piece from the elephant
-  eat it
-  if (something left) {
-*!*
-    eat(what's left of the elephant)  // (*)
-*/!*
-  }
-}
-```
-
-The recursion occurs at line `(*)`: function `eat` after making things simpler passes the remaining data again to itself.
-
-Of course that's only one variant. For example, we could cut the elephant in 2 halves, then cut the halves in half again etc, until the parts are small enough to eat. Then put them into plates and pass to the guests.
-
-The core idea is the same: splitting the problem into multiple subproblems and doing the same with them if they're still big.
-
-## A power of a number
-
-
-
-## Степень pow(x, n) через рекурсию
-
-В качестве первого примера использования рекурсивных вызовов -- рассмотрим задачу возведения числа `x` в натуральную степень `n`.
-
-Её можно представить как совокупность более простого действия и более простой задачи того же типа вот так: 
-
-```js
-pow(x, n) = x * pow(x, n - 1)
-```
-
-То есть, <code>x<sup>n</sup> = x * x<sup>n-1</sup></code>.
-
-Например, вычислим `pow(2, 4)`, последовательно переходя к более простой задаче:
-
-<ol>
-<li>`pow(2, 4) = 2 * pow(2, 3)`</li>
-<li>`pow(2, 3) = 2 * pow(2, 2)`</li>
-<li>`pow(2, 2) = 2 * pow(2, 1)`</li>
-<li>`pow(2, 1) = 2`</li>
-</ol>
-
-На шаге 1 нам нужно вычислить `pow(2,3)`, поэтому мы делаем шаг 2, дальше нам нужно `pow(2,2)`, мы делаем шаг 3, затем шаг 4, и на нём уже можно остановиться, ведь очевидно, что результат возведения числа в степень 1 -- равен самому числу.
-
-Далее, имея результат на шаге 4, он подставляется обратно в шаг 3, затем имеем `pow(2,2)` -- подставляем в шаг 2 и на шаге 1 уже получаем результат.
-
-Этот алгоритм на JavaScript:
-
-```js
-//+ run
-function pow(x, n) {
-  if (n != 1) { // пока n != 1, сводить вычисление pow(x,n) к pow(x,n-1)
-    return x * pow(x, n - 1);
-  } else {
-    return x;
-  }
-}
-
-alert( pow(2, 3) ); // 8
-```
-
-Говорят, что "функция `pow` *рекурсивно вызывает сама себя*" до `n == 1`. 
-
-Значение, на котором рекурсия заканчивается называют *базисом рекурсии*. В примере выше базисом является `1`.
-
-Общее количество вложенных вызовов называют *глубиной рекурсии*. В случае со степенью, всего будет `n` вызовов. 
-
-Максимальная глубина рекурсии в браузерах ограничена, точно можно рассчитывать на `10000` вложенных вызовов, но некоторые интерпретаторы допускают и больше.
-
-Итак, рекурсию используют, когда вычисление функции можно свести к её более простому вызову, а его -- ещё к более простому, и так далее, пока значение не станет очевидно.
-
-## Контекст выполнения, стек
-
-Теперь мы посмотрим, как работают рекурсивные вызовы. Для этого мы рассмотрим, как вообще работают функции, что происходит при вызове.
-
-**У каждого вызова функции есть свой "контекст выполнения" (execution context).** 
-
-Контекст выполнения -- это служебная информация, которая соответствует текущему запуску функции. Она включает в себя локальные переменные функции и конкретное место в коде, на котором находится интерпретатор.
-
-Например, для вызова `pow(2, 3)` из примера выше будет создан контекст выполнения, который будет хранить переменные `x = 2, n = 3`. Мы схематично обозначим его так:
-
-<ul class="function-execution-context">
-  <li>Контекст: { x: 2, n: 3, строка 1 }</li>
-</ul>
-
-Далее функция `pow` начинает выполняться. Вычисляется выражение `n != 1` -- оно равно `true`, ведь в текущем контексте `n=3`. Поэтому задействуется первая ветвь `if` :
-
-```js
-function pow(x, n) {
-  if (n != 1) { // пока n != 1 сводить вычисление pow(x,n) к pow(x,n-1)
-*!*
-    return x * pow(x, n - 1);
-*/!*
-  } else {
-    return x;
-  }
-}
-```
-
-Чтобы вычислить выражение `x * pow(x, n-1)`, требуется произвести запуск `pow` с новыми аргументами.
-
-**При любом вложенном вызове JavaScript запоминает текущий контекст выполнения в специальной внутренней структуре данных -- "стеке контекстов".**
-
-Затем интерпретатор приступает к выполнению вложенного вызова.
-
-В данном случае вызывается та же `pow`, однако это абсолютно неважно. Для любых функций процесс одинаков.
-
-Для нового вызова создаётся свой контекст выполнения, и управление переходит в него, а когда он завершён -- старый контекст достаётся из стека и выполнение внешней функции возобновляется.
-
-Разберём происходящее с контекстами более подробно, начиная с вызова `(*)`:
-
-```js
-//+ run
-function pow(x, n) {
-  if (n != 1) { // пока n!=1 сводить вычисление pow(..n) к pow(..n-1)
-    return x * pow(x, n - 1);
-  } else {
-    return x;
-  }
-}
-
-*!*
-alert( pow(2, 3) ); // (*)
-*/!*
-```
-
-<dl>
-<dt>`pow(2, 3)`</dt>
-<dd>Запускается функция `pow`, с аргументами `x=2`, `n=3`. Эти переменные хранятся в контексте выполнения, схематично изображённом ниже:
-
-<ul class="function-execution-context">
-  <li>Контекст: { x: 2, n: 3, строка 1 }</li>
-</ul>
-Выполнение в этом контексте продолжается, пока не встретит вложенный вызов в строке 3.
-</dd>
-<dt>`pow(2, 2)`</dt>
-<dd>В строке `3` происходит вложенный вызов `pow` с аргументами `x=2`, `n=2`. Текущий контекст сохраняется в стеке, а для вложеннного вызова создаётся новый контекст (выделен жирным ниже):
-
-<ul class="function-execution-context">
-  <li>Контекст: { x: 2, n: 3, строка 3 }</li>
-  <li>Контекст: { x: 2, n: 2, строка 1 }</li>
-</ul>
-Обратим внимание, что контекст включает в себя не только переменные, но и место в коде, так что когда вложенный вызов завершится -- можно будет легко вернуться назад.
-
-Слово "строка" здесь условно, на самом деле, конечно, запомнено более точное место в цепочке команд.
-</dd>
-<dt>`pow(2, 1)`</dt>
-<dd>Опять вложенный вызов в строке `3`, на этот раз -- с аргументами `x=2`, `n=1`. Создаётся новый текущий контекст, предыдущий добавляется в стек:
-<ul class="function-execution-context">
-  <li>Контекст: { x: 2, n: 3, строка 3 }</li>
-  <li>Контекст: { x: 2, n: 2, строка 3 }</li>
-  <li>Контекст: { x: 2, n: 1, строка 1 }</li>
-</ul>
-На текущий момент в стеке уже два старых контекста.
-</dd>
-<dt>Выход из `pow(2, 1)`.</dt>
-<dd>При выполнении `pow(2, 1)`, в отличие от предыдущих запусков, выражение `n != 1` будет равно `false`, поэтому  сработает вторая ветка `if..else`:
-
-```js
-function pow(x, n) {
-  if (n != 1) {
-    return x * pow(x, n - 1);
-  } else {
-*!*
-    return x; // первая степень числа равна самому числу
-*/!*
-  }
-}
-```
-
-Здесь вложенных вызовов нет, так что функция заканчивает свою работу, возвращая `2`. Текущий контекст больше не нужен и удаляется из памяти, из стека восстанавливается предыдущий:
-
-<ul class="function-execution-context">
-  <li>Контекст: { x: 2, n: 3, строка 3 }</li>
-  <li>Контекст: { x: 2, n: 2, строка 3 }</li>
-</ul>
-Возобновляется обработка внешнего вызова `pow(2, 2)`.
-</dd>
-<dt>Выход из `pow(2, 2)`.</dt>
-<dd>...И теперь уже `pow(2, 2)` может закончить свою работу, вернув `4`. Восстанавливается контекст предыдущего вызова:
-<ul class="function-execution-context">
-  <li>Контекст: { x: 2, n: 3, строка 3 }</li>
-</ul>
-Возобновляется обработка внешнего вызова `pow(2, 3)`.
-</dd>
-<dt>Выход из `pow(2, 3)`.</dt>
-<dd>Самый внешний вызов заканчивает свою работу, его результат: `pow(2, 3) = 8`.</dd>
-</dl>
-
-Глубина рекурсии в данном случае составила: **3**.
-
-Как видно из иллюстраций выше, глубина рекурсии равна максимальному числу контекстов, одновременно хранимых в стеке.
-
-Обратим внимание на требования к памяти. Рекурсия приводит к хранению всех данных для неоконченных внешних вызовов в стеке, в данном случае это приводит к тому, что возведение в степень `n` хранит в памяти `n` различных контекстов.
-
-Реализация возведения в степень через цикл гораздо более экономна:
-
-```js
-function pow(x, n) {
-  let result = x;
-  for let i = 1; i < n; i++) {
-    result *= x;
-  }
-  return result;
-}
-```
-
-У такой функции `pow` будет один контекст, в котором будут последовательно меняться значения `i` и `result`.
-
-**Любая рекурсия может быть переделана в цикл. Как правило, вариант с циклом будет эффективнее.**
-
-Но переделка рекурсии в цикл может быть нетривиальной, особенно когда в функции, в зависимости от условий, используются различные рекурсивные подвызовы, когда ветвление более сложное.
-
-## Итого
-
-Рекурсия -- это когда функция вызывает сама себя, как правило, с другими аргументами.
-
-Существуют много областей применения рекурсивных вызовов. Здесь мы посмотрели на один из них -- решение задачи путём сведения её к более простой (с меньшими аргументами), но также рекурсия используется для работы с "естественно рекурсивными" структурами данных, такими как HTML-документы, для "глубокого" копирования сложных объектов. 
-
-Есть и другие применения, с которыми мы встретимся по мере изучения JavaScript.
-
-Здесь мы постарались рассмотреть происходящее достаточно подробно, однако, если пожелаете, допустимо временно забежать вперёд и открыть главу [](/debugging-chrome), с тем чтобы при помощи отладчика построчно пробежаться по коду и посмотреть стек на каждом шаге. Отладчик даёт к нему доступ.
-
-
-
-[head]
-<style>
-.function-execution-context {
-  margin: 0;
-  padding: 0;
-  overflow: auto;
-}
-
-.function-execution-context li {
-  float: left;
-  clear: both;
-  border: 1px solid black;
-  font-family: "Consolas", monospace;
-  padding: 3px 5px;
-}
-
-
-.function-execution-context li:last-child {
-  font-weight: bold;
-}
-</style>
-[/head]
-
diff --git a/archive/timing-decorator.md b/archive/timing-decorator.md
deleted file mode 100644
index b412f5c416..0000000000
--- a/archive/timing-decorator.md
+++ /dev/null
@@ -1,105 +0,0 @@
-
-
-## Instrumentation: timing decorator
-
-Let's say we have a function and want to measure time it takes to run.
-
-Of course, we could modify it. Add something like `timerStart()` to the start and `timerEnd()` to all exit points. Then later we may want to log which arguments it receives and results. That requires additional code as well. 
-
-That is called [instrumentation](https://en.wikipedia.org/wiki/Instrumentation) of the code -- adding stuff to measure times, log what's happening and do other watching/measuring without interfering with the main functionality.
-
-Putting instrumentation inside the function manually is not pretty at all. It takes space, shadows the core functionality and makes it harder to debug.
-
-There are tools that analyze javascript code and add instrumentation calls to it automatically. But here we'll take a "median" approach. We will "wrap" instrumentation over function without touching its code.
-
-What we going to do is a special function `timingDecorator(func)`, that takes a function `func` and returns a "wrapper" around it, that transfers all calls to `func` and measures time they take.
-
-For simplicity let's assume that `func` has only one argument. 
-
-The code with `timingDecorator` and example function:
-
-
-
-
-```js run
-function fibo(n) { // a function to measure, here we count fibonacci number
-  return (n > 2) ? fibo(n - 1) + fibo(n - 2) : 1; 
-}
-
-let timers = {}; // timers to store data
-
-function timingDecorator(func) {
-  return function(x) {
-    let start = performance.now();
-
-    let result = func(x);
-
-    let time = performance.now() - start;
-
-    if (!timers[func.name]) timers[func.name] = 0;
-    timers[func.name] += time;
-
-    return result;
-  };  
-}
-
-// decorate it
-fibo = timingDecorator(fibo);
-
-// run
-alert( fibo(10) ); // 55
-alert( fibo(20) ); // 6765
-alert( fibo(30) ); // 832040
-
-alert( `Total time: ${timers.fibo.toFixed(3)}ms` ); // total count of fibo calls
-```
-
-При помощи декоратора `timingDecorator` мы сможем взять произвольную функцию и одним движением руки прикрутить к ней измеритель времени.
-
-Его реализация:
-
-```js run
-let timers = {};
-
-// прибавит время выполнения f к таймеру timers[timer]
-function timingDecorator(f, timer) {
-  return function() {
-    let start = performance.now();
-
-    let result = f.apply(this, arguments); // (*)
-
-    if (!timers[timer]) timers[timer] = 0;
-    timers[timer] += performance.now() - start;
-
-    return result;
-  }
-}
-
-// функция может быть произвольной, например такой:
-let fibonacci = function f(n) {
-  return (n > 2) ? f(n - 1) + f(n - 2) : 1;
-}
-
-*!*
-// использование: завернём fibonacci в декоратор
-fibonacci = timingDecorator(fibonacci, "fibo");
-*/!*
-
-// неоднократные вызовы...
-alert( fibonacci(10) ); // 55
-alert( fibonacci(20) ); // 6765
-// ...
-
-*!*
-// в любой момент можно получить общее количество времени на вызовы
-alert( timers.fibo + 'мс' );
-*/!*
-```
-
-Обратим внимание на строку `(*)` внутри декоратора, которая и осуществляет передачу вызова:
-
-```js
-let result = f.apply(this, arguments); // (*)
-```
-
-Этот приём называется "форвардинг вызова" (от англ. forwarding): текущий контекст и аргументы через `apply` передаются в функцию `f`, так что изнутри `f` всё выглядит так, как была вызвана она напрямую, а не декоратор.
diff --git a/figures.sketch b/figures.sketch
index 6908c2ed70..bebfcd3ec5 100644
Binary files a/figures.sketch and b/figures.sketch differ
diff --git a/todo.md b/todo.md
new file mode 100644
index 0000000000..331e3f4783
--- /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)