From 5aa692f5f3bbfa7b79224748dcfd8ca5fba7a8bc Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Fri, 12 Feb 2016 11:42:25 -0800
Subject: brainfuck->bf

---
 bf.html.markdown                 | 81 ++++++++++++++++++++++++++++++++++
 brainfuck.html.markdown          | 81 ----------------------------------
 es-es/bf-es.html.markdown        | 89 ++++++++++++++++++++++++++++++++++++++
 es-es/brainfuck-es.html.markdown | 89 --------------------------------------
 fa-ir/bf-fa.html.markdown        | 81 ++++++++++++++++++++++++++++++++++
 fa-ir/brainfuck-fa.html.markdown | 81 ----------------------------------
 fr-fr/bf-fr.html.markdown        | 87 +++++++++++++++++++++++++++++++++++++
 fr-fr/brainfuck-fr.html.markdown | 87 -------------------------------------
 it-it/bf-it.html.markdown        | 92 +++++++++++++++++++++++++++++++++++++++
 it-it/brainfuck-it.html.markdown | 92 ---------------------------------------
 ko-kr/bf-kr.html.markdown        | 84 ++++++++++++++++++++++++++++++++++++
 ko-kr/brainfuck-kr.html.markdown | 84 ------------------------------------
 nl-nl/bf.html.markdown           | 86 +++++++++++++++++++++++++++++++++++++
 nl-nl/brainfuck-nl.html.markdown | 86 -------------------------------------
 pl-pl/bf-pl.html.markdown        | 93 ++++++++++++++++++++++++++++++++++++++++
 pl-pl/brainfuck-pl.html.markdown | 93 ----------------------------------------
 pt-br/bf.html.markdown           | 85 ++++++++++++++++++++++++++++++++++++
 pt-br/brainfuck-pt.html.markdown | 85 ------------------------------------
 pt-pt/bf.html.markdown           | 84 ++++++++++++++++++++++++++++++++++++
 pt-pt/brainfuck-pt.html.markdown | 84 ------------------------------------
 ru-ru/bf.html.markdown           | 85 ++++++++++++++++++++++++++++++++++++
 ru-ru/brainfuck-ru.html.markdown | 85 ------------------------------------
 tr-tr/bf-tr.html.markdown        | 87 +++++++++++++++++++++++++++++++++++++
 tr-tr/brainfuck-tr.html.markdown | 87 -------------------------------------
 zh-cn/bf-cn.html.markdown        | 70 ++++++++++++++++++++++++++++++
 zh-cn/brainfuck-cn.html.markdown | 70 ------------------------------
 26 files changed, 1104 insertions(+), 1104 deletions(-)
 create mode 100644 bf.html.markdown
 delete mode 100644 brainfuck.html.markdown
 create mode 100644 es-es/bf-es.html.markdown
 delete mode 100644 es-es/brainfuck-es.html.markdown
 create mode 100644 fa-ir/bf-fa.html.markdown
 delete mode 100644 fa-ir/brainfuck-fa.html.markdown
 create mode 100644 fr-fr/bf-fr.html.markdown
 delete mode 100644 fr-fr/brainfuck-fr.html.markdown
 create mode 100644 it-it/bf-it.html.markdown
 delete mode 100644 it-it/brainfuck-it.html.markdown
 create mode 100644 ko-kr/bf-kr.html.markdown
 delete mode 100644 ko-kr/brainfuck-kr.html.markdown
 create mode 100644 nl-nl/bf.html.markdown
 delete mode 100644 nl-nl/brainfuck-nl.html.markdown
 create mode 100644 pl-pl/bf-pl.html.markdown
 delete mode 100644 pl-pl/brainfuck-pl.html.markdown
 create mode 100644 pt-br/bf.html.markdown
 delete mode 100644 pt-br/brainfuck-pt.html.markdown
 create mode 100644 pt-pt/bf.html.markdown
 delete mode 100644 pt-pt/brainfuck-pt.html.markdown
 create mode 100644 ru-ru/bf.html.markdown
 delete mode 100644 ru-ru/brainfuck-ru.html.markdown
 create mode 100644 tr-tr/bf-tr.html.markdown
 delete mode 100644 tr-tr/brainfuck-tr.html.markdown
 create mode 100644 zh-cn/bf-cn.html.markdown
 delete mode 100644 zh-cn/brainfuck-cn.html.markdown

diff --git a/bf.html.markdown b/bf.html.markdown
new file mode 100644
index 00000000..c8bbee61
--- /dev/null
+++ b/bf.html.markdown
@@ -0,0 +1,81 @@
+---
+language: bf
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+---
+
+Brainfuck (not capitalized except at the start of a sentence) is an extremely
+minimal Turing-complete programming language with just 8 commands.
+
+You can try brainfuck on your browser with [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+```
+Any character not "><+-.,[]" (excluding quotation marks) is ignored.
+
+Brainfuck is represented by an array with 30,000 cells initialized to zero
+and a data pointer pointing at the current cell.
+
+There are eight commands:
++ : Increments the value at the current cell by one.
+- : Decrements the value at the current cell by one.
+> : Moves the data pointer to the next cell (cell on the right).
+< : Moves the data pointer to the previous cell (cell on the left).
+. : Prints the ASCII value at the current cell (i.e. 65 = 'A').
+, : Reads a single input character into the current cell.
+[ : If the value at the current cell is zero, skips to the corresponding ] .
+    Otherwise, move to the next instruction.
+] : If the value at the current cell is zero, move to the next instruction.
+    Otherwise, move backwards in the instructions to the corresponding [ .
+
+[ and ] form a while loop. Obviously, they must be balanced.
+
+Let's look at some basic brainfuck programs.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+This program prints out the letter 'A'. First, it increments cell #1 to 6.
+Cell #1 will be used for looping. Then, it enters the loop ([) and moves
+to cell #2. It increments cell #2 10 times, moves back to cell #1, and
+decrements cell #1. This loop happens 6 times (it takes 6 decrements for
+cell #1 to reach 0, at which point it skips to the corresponding ] and
+continues on).
+
+At this point, we're on cell #1, which has a value of 0, while cell #2 has a
+value of 60. We move on cell #2, increment 5 times, for a value of 65, and then
+print cell #2's value. 65 is 'A' in ASCII, so 'A' is printed to the terminal.
+
+
+, [ > + < - ] > .
+
+This program reads a character from the user input and copies the character into
+cell #1. Then we start a loop. Move to cell #2, increment the value at cell #2,
+move back to cell #1, and decrement the value at cell #1. This continues on
+until cell #1 is 0, and cell #2 holds cell #1's old value. Because we're on
+cell #1 at the end of the loop, move to cell #2, and then print out the value
+in ASCII.
+
+Also keep in mind that the spaces are purely for readability purposes. You
+could just as easily write it as:
+
+,[>+<-]>.
+
+Try and figure out what this program does:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+This program takes two numbers for input, and multiplies them.
+
+The gist is it first reads in two inputs. Then it starts the outer loop,
+conditioned on cell #1. Then it moves to cell #2, and starts the inner
+loop conditioned on cell #2, incrementing cell #3. However, there comes a
+problem: At the end of the inner loop, cell #2 is zero. In that case,
+inner loop won't work anymore since next time. To solve this problem,
+we also increment cell #4, and then recopy cell #4 into cell #2.
+Then cell #3 is the result.
+```
+
+And that's brainfuck. Not that hard, eh? For fun, you can write your own
+brainfuck programs, or you can write a brainfuck interpreter in another
+language. The interpreter is fairly simple to implement, but if you're a
+masochist, try writing a brainfuck interpreter… in brainfuck.
diff --git a/brainfuck.html.markdown b/brainfuck.html.markdown
deleted file mode 100644
index a76169c8..00000000
--- a/brainfuck.html.markdown
+++ /dev/null
@@ -1,81 +0,0 @@
----
-language: brainfuck
-contributors:
-    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-    - ["Mathias Bynens", "http://mathiasbynens.be/"]
----
-
-Brainfuck (not capitalized except at the start of a sentence) is an extremely
-minimal Turing-complete programming language with just 8 commands.
-
-You can try brainfuck on your browser with [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
-
-```
-Any character not "><+-.,[]" (excluding quotation marks) is ignored.
-
-Brainfuck is represented by an array with 30,000 cells initialized to zero
-and a data pointer pointing at the current cell.
-
-There are eight commands:
-+ : Increments the value at the current cell by one.
-- : Decrements the value at the current cell by one.
-> : Moves the data pointer to the next cell (cell on the right).
-< : Moves the data pointer to the previous cell (cell on the left).
-. : Prints the ASCII value at the current cell (i.e. 65 = 'A').
-, : Reads a single input character into the current cell.
-[ : If the value at the current cell is zero, skips to the corresponding ] .
-    Otherwise, move to the next instruction.
-] : If the value at the current cell is zero, move to the next instruction.
-    Otherwise, move backwards in the instructions to the corresponding [ .
-
-[ and ] form a while loop. Obviously, they must be balanced.
-
-Let's look at some basic brainfuck programs.
-
-++++++ [ > ++++++++++ < - ] > +++++ .
-
-This program prints out the letter 'A'. First, it increments cell #1 to 6.
-Cell #1 will be used for looping. Then, it enters the loop ([) and moves
-to cell #2. It increments cell #2 10 times, moves back to cell #1, and
-decrements cell #1. This loop happens 6 times (it takes 6 decrements for
-cell #1 to reach 0, at which point it skips to the corresponding ] and
-continues on).
-
-At this point, we're on cell #1, which has a value of 0, while cell #2 has a
-value of 60. We move on cell #2, increment 5 times, for a value of 65, and then
-print cell #2's value. 65 is 'A' in ASCII, so 'A' is printed to the terminal.
-
-
-, [ > + < - ] > .
-
-This program reads a character from the user input and copies the character into
-cell #1. Then we start a loop. Move to cell #2, increment the value at cell #2,
-move back to cell #1, and decrement the value at cell #1. This continues on
-until cell #1 is 0, and cell #2 holds cell #1's old value. Because we're on
-cell #1 at the end of the loop, move to cell #2, and then print out the value
-in ASCII.
-
-Also keep in mind that the spaces are purely for readability purposes. You
-could just as easily write it as:
-
-,[>+<-]>.
-
-Try and figure out what this program does:
-
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
-
-This program takes two numbers for input, and multiplies them.
-
-The gist is it first reads in two inputs. Then it starts the outer loop,
-conditioned on cell #1. Then it moves to cell #2, and starts the inner
-loop conditioned on cell #2, incrementing cell #3. However, there comes a
-problem: At the end of the inner loop, cell #2 is zero. In that case,
-inner loop won't work anymore since next time. To solve this problem,
-we also increment cell #4, and then recopy cell #4 into cell #2.
-Then cell #3 is the result.
-```
-
-And that's brainfuck. Not that hard, eh? For fun, you can write your own
-brainfuck programs, or you can write a brainfuck interpreter in another
-language. The interpreter is fairly simple to implement, but if you're a
-masochist, try writing a brainfuck interpreter… in brainfuck.
diff --git a/es-es/bf-es.html.markdown b/es-es/bf-es.html.markdown
new file mode 100644
index 00000000..c93b8c3a
--- /dev/null
+++ b/es-es/bf-es.html.markdown
@@ -0,0 +1,89 @@
+---
+language: bf
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Daniel Zendejas", "https://github.com/DanielZendejas"]
+lang: es-es
+---
+
+Brainfuck (con mayúscula sólo al inicio de una oración) es un
+lenguaje de programación extremadamente pequeño, Turing completo con sólo 8 comandos.
+
+Puedes probar brainfuck en tu navegador con [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+
+```
+
+Cualquier caracter que no sea "><+-.,[]" (sin incluir las comillas)
+será ignorado.
+
+Brainfuck es representado por un arreglo de 30,000 celdas inicializadas
+en cero y un puntero apuntando la celda actual.
+
+Existen ocho comandos:
+
++ : Incrementa 1 al valor de la celda actual.
+- : Decrementa 1 al valor de la celda actual.
+> : Mueve el apuntador a la siguiente celda. (a la derecha)
+< : Mueve el apuntador a la celda anterior. (a la izquierda)
+. : Imprime el valor en ASCII de la celda actual (p.e. 65 = 'A')
+, : Lee un caracter como input y lo escribe en la celda actual.
+[ : Si el valor en la celda actual es cero mueve el apuntador
+	hasta el primer ']' que encuentre. Si no es cero sigue a la
+	siguiente instrucción.
+] : Si el valor en la celda actual es cero, entonces sigue con 
+	la siguiente instrucción. Si no entonces mueve el apuntador
+	hacia atrás	hasta encontrar el primer '['.
+
+[ y ] forman un while. Obviamente, deben estar balanceados.
+
+Estos son algunos ejemplos de programas escritos con brainfuck.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Este programa imprime la letra 'A'. Primero, incrementa la celda #1 a 
+6. La celda #1 será usada para hacer los ciclos. Después entra al ciclo
+([) y se mueve a la celda #2 (>). Después incrementa la celda #2 10 veces,
+y se regresa a la celda #1 (<), para después decrementarla en 1 (-).
+Este ciclo ocurre 6 veces (le toma 6 decrementos a la celda #1 volverse 0),
+cuando esto pasa se salta a (]) y continúa.
+
+En este punto estamos en la celda #1, que tiene un valor de 0, mientras
+que la celda #2 tiene un valor de 60. Nos movemos a la celda #2 (>),
+la incrementamos 5 veces para tener un valor de 65 y luego imprimimos
+el valor de la celda #2 (.). 65 es 'A' en ASCII así que la letra 'A'
+se imprime.
+
+, [ > + < - ] > .
+
+Este programa lee un caracter del input y lo copia en la celda #2 (,). 
+Después empieza un ciclo. Nos movemos a la celda #2 (>) e incrementamos su
+valor (+). Regresamos a la celda #1 y decrementamos su valor en 1 (-).
+Esto continúa hasta que la celda #1 contenga un cero. Cuando #1 contenga un 
+cero la celda #2 tendrá el valor inicial de #1. Como este ciclo siempre
+terminara en la celda #1 nos movemos a la celda #2 e imprimimos (.).
+
+Ten en cuenta que los espacios son sólo para fines de legibilidad.
+Es lo mismo escribir el ejemplo de arriba que esto:
+,[>+<-]>.
+
+Intenta descrifrar lo que hace este programa:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Este programa toma dos números como input y los multiplica.
+
+Primero recibe dos números del usuario. Luego empieza el ciclo externo,
+condicionado en la celda #1. Luego se mueve a la celda #2, comenzando
+el ciclo interno condicionado en la celda #2 incrementando la celda #3.
+Sin embargo viene un problema: El ciclo interior no funcionará nuevamente
+hasta la próxima vez. Para resolver este problema también incrementamos la
+celda #4 y luego copiamos la celda #4 a la celda #2. La celda #3 contiene
+el resultado.
+```
+Y eso es brainfuck. No es tan difícil, ¿verdad? Como diversión, puedes escribir
+tu propio intérprete de brainfuck o tu propio programa en brainfuck. El
+intérprete es relativamente sencillo de hacer, pero si eres masoquista,
+puedes intentar construir tu propio intérprete de brainfuck... en brainfuck.
diff --git a/es-es/brainfuck-es.html.markdown b/es-es/brainfuck-es.html.markdown
deleted file mode 100644
index 550511da..00000000
--- a/es-es/brainfuck-es.html.markdown
+++ /dev/null
@@ -1,89 +0,0 @@
----
-language: brainfuck
-contributors:
-    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-    - ["Mathias Bynens", "http://mathiasbynens.be/"]
-translators:
-    - ["Daniel Zendejas", "https://github.com/DanielZendejas"]
-lang: es-es
----
-
-Brainfuck (con mayúscula sólo al inicio de una oración) es un
-lenguaje de programación extremadamente pequeño, Turing completo con sólo 8 comandos.
-
-Puedes probar brainfuck en tu navegador con [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
-
-
-```
-
-Cualquier caracter que no sea "><+-.,[]" (sin incluir las comillas)
-será ignorado.
-
-Brainfuck es representado por un arreglo de 30,000 celdas inicializadas
-en cero y un puntero apuntando la celda actual.
-
-Existen ocho comandos:
-
-+ : Incrementa 1 al valor de la celda actual.
-- : Decrementa 1 al valor de la celda actual.
-> : Mueve el apuntador a la siguiente celda. (a la derecha)
-< : Mueve el apuntador a la celda anterior. (a la izquierda)
-. : Imprime el valor en ASCII de la celda actual (p.e. 65 = 'A')
-, : Lee un caracter como input y lo escribe en la celda actual.
-[ : Si el valor en la celda actual es cero mueve el apuntador
-	hasta el primer ']' que encuentre. Si no es cero sigue a la
-	siguiente instrucción.
-] : Si el valor en la celda actual es cero, entonces sigue con 
-	la siguiente instrucción. Si no entonces mueve el apuntador
-	hacia atrás	hasta encontrar el primer '['.
-
-[ y ] forman un while. Obviamente, deben estar balanceados.
-
-Estos son algunos ejemplos de programas escritos con brainfuck.
-
-++++++ [ > ++++++++++ < - ] > +++++ .
-
-Este programa imprime la letra 'A'. Primero, incrementa la celda #1 a 
-6. La celda #1 será usada para hacer los ciclos. Después entra al ciclo
-([) y se mueve a la celda #2 (>). Después incrementa la celda #2 10 veces,
-y se regresa a la celda #1 (<), para después decrementarla en 1 (-).
-Este ciclo ocurre 6 veces (le toma 6 decrementos a la celda #1 volverse 0),
-cuando esto pasa se salta a (]) y continúa.
-
-En este punto estamos en la celda #1, que tiene un valor de 0, mientras
-que la celda #2 tiene un valor de 60. Nos movemos a la celda #2 (>),
-la incrementamos 5 veces para tener un valor de 65 y luego imprimimos
-el valor de la celda #2 (.). 65 es 'A' en ASCII así que la letra 'A'
-se imprime.
-
-, [ > + < - ] > .
-
-Este programa lee un caracter del input y lo copia en la celda #2 (,). 
-Después empieza un ciclo. Nos movemos a la celda #2 (>) e incrementamos su
-valor (+). Regresamos a la celda #1 y decrementamos su valor en 1 (-).
-Esto continúa hasta que la celda #1 contenga un cero. Cuando #1 contenga un 
-cero la celda #2 tendrá el valor inicial de #1. Como este ciclo siempre
-terminara en la celda #1 nos movemos a la celda #2 e imprimimos (.).
-
-Ten en cuenta que los espacios son sólo para fines de legibilidad.
-Es lo mismo escribir el ejemplo de arriba que esto:
-,[>+<-]>.
-
-Intenta descrifrar lo que hace este programa:
-
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
-
-Este programa toma dos números como input y los multiplica.
-
-Primero recibe dos números del usuario. Luego empieza el ciclo externo,
-condicionado en la celda #1. Luego se mueve a la celda #2, comenzando
-el ciclo interno condicionado en la celda #2 incrementando la celda #3.
-Sin embargo viene un problema: El ciclo interior no funcionará nuevamente
-hasta la próxima vez. Para resolver este problema también incrementamos la
-celda #4 y luego copiamos la celda #4 a la celda #2. La celda #3 contiene
-el resultado.
-```
-Y eso es brainfuck. No es tan difícil, ¿verdad? Como diversión, puedes escribir
-tu propio intérprete de brainfuck o tu propio programa en brainfuck. El
-intérprete es relativamente sencillo de hacer, pero si eres masoquista,
-puedes intentar construir tu propio intérprete de brainfuck... en brainfuck.
diff --git a/fa-ir/bf-fa.html.markdown b/fa-ir/bf-fa.html.markdown
new file mode 100644
index 00000000..bc5d8dc4
--- /dev/null
+++ b/fa-ir/bf-fa.html.markdown
@@ -0,0 +1,81 @@
+---
+language: bf
+contributors:
+    - ["Mohammad Valipour", "https://github.com/mvalipour"]
+lang: fa-ir
+---
+
+<p dir='rtl'>برین فاک زبان برنامه نویسی تورینگ کامل بی نهایت ساده ایست که دارای فقط هشت</p>
+<p dir='rtl'>دستور است.</p>
+
+<p dir='rtl'>هر کارکتری به جر کارکتر های زیر در این زبان در نظر گرفته نمیشود.</p>
+
+
+`>` `<` `+` `-` `.` `,` `[` `]`
+
+<p dir='rtl'>برین فاک به صورت یک آرایه ی سی هزار خانه ای کار میکند که در ابتدا تمامی خانه های آن صفر هستند.</p>
+<p dir='rtl'>همچنین یک اشاره گر در این برنامه به خانه ی فعلی اشاره میکند.</p>
+
+<p dir='rtl'>در زیر هشت دستور این زبان شرح داده شده است:</p>
+
+<p dir='rtl'>`+` : یک عدد به خانه ی فعلی اضافه می کند.
+<p dir='rtl'>`-` : یک عدد از خانه ی فعلی کم می کند.  </p>
+<p dir='rtl'>`>` : اشاره گر به خانه ی بعدی میرود -- به راست</p>
+<p dir='rtl'>`<` : اشاره گر به خانه ی قبلی میرود -- به چپ</p>
+<p dir='rtl'>`.` : کارکتر اسکی معادل مقدار خانه ی فعلی را چاپ میکند. -- به عنوان مثال 65 برای A</p>
+<p dir='rtl'>`,` : یک کارکتر را از ورودی خوانده و مقدار آن را در خانه ی فعلی زخیره میکند.</p>
+<p dir='rtl'>`[` : اگر مقدار خانه ی فعلی صفر باشد به محل بسته شدن کروشه جهش میکند. -- و از همه ی دستور های بین آن صرف نظر میشود.</p>
+<p dir='rtl'>در غیر این صورت به دستور بعدی میرود.</p>
+<p dir='rtl'>`]` : اگر مقدار خانه ی فعلی صفر باشد به خانه ی بعدی و در غیر این صورت به محل باز شدن کروشه جهش می کند. -- به عقب</p>
+
+<p dir='rtl'>دو علامت کروشه امکان ایجاد حلقه را فراهم میکنند.</p>
+
+<p dir='rtl'>در اینجا یک برنامه ی ساره برین فاک را مشاهده میکنید.</p>
+
+```
+++++++ [ > ++++++++++ < - ] > +++++ .
+```
+
+<p dir='rtl'>این برنامه کارکتر A را بر روی خروجی چاپ میکند.</p>
+<p dir='rtl'>در این برنامه خانه ی اول به عنوان متغیر حلقه و خانه ی دوم برای مقدار عددی A</p>
+<p dir='rtl'>ابتدا عدد شش در خانه ی اول ایجاد شده. سپس  برنامه  وارد یک حلقه میشود که در هر بار </p>
+<p dir='rtl'>تکرار آن اشاره گر به خانه ی دوم رفته و ده بار به خانه ی فعلی اضافه می کند.</p>
+<p dir='rtl'>-- و در انتهای حلقه به خانه ی اول برگشته تا حلقه کنترل شود</p>
+<p dir='rtl'>بعد از اتمام حلقه به خانه ی دوم میرود و پنج بار به این خانه اضافه کرده و سپس آنرا چاپ میکند.</p>
+
+```
+, [ > + < - ] > .
+```
+
+<p dir='rtl'>در این برنامه ابتدا یک کارکتر از ورودی خوانده می شود. سپس یک حلقه به تعداد بار مقدار</p>
+<p dir='rtl'>عددی کارکتر، یک عدد به خانه ی دوم اضافه می کند. با این کار در واقع برنامه مقدار ورودی را در خانه ی </p>
+<p dir='rtl'>دوم کپی می کند. و در نهایت آن را برروی خروجی چاپ می کند.</p>
+
+<p dir='rtl'>توجه داشته باشید که ردر بالا فواصل بین دستور ها فقط برای خوانایی بیشتر گذاشته شده اند.</p>
+<p dir='rtl'>در واقع برنامه بالا به شکل زیر صحیح می باشد.</p>
+
+```
+,[>+<-]>.
+```
+
+<p dir='rtl'>حال سعی کنید ببینید که برنامه ی زیر چه کاری انجام می دهد؟</p>
+
+```
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+```
+
+<p dir='rtl'>این برنامه دو عدد را از ورودی خوانده و با هم ضرب می کند.</p>
+
+<p dir='rtl'>ابتدا دو عدد از ورودی خوانده می شوند. سپس حلقه ی بیرونی بر روی خانه شماره یک شروع میشود.</p>
+<p dir='rtl'>و درون آن حلقه ی دیگری بر روی خانه ی دوم شروع میشود که خانه ی 3 را زیاد میکند.</p>
+<p dir='rtl'>ولی مشکلی که در اینجا به وجود می آید اینست که در پایان حلقه ی دوم مقدار خانه ی 2 صفر شده</p>
+<p dir='rtl'>و مقدار اولیه ی آن از دست رفته است. برای حل این مشکل خانه ی شماره چهار هم زیاد میشود</p>
+<p dir='rtl'>و در پایان حلقه مقدار آن به خانه 2 کپی میشود.</p>
+<p dir='rtl'>در پایان خانه ی شماره 2  حاوی حاصلضرب خواهد بود.</p>
+
+<hr>
+
+<p dir='rtl'>و این همه ی برین فاک بود! خیلی ساده برای یادگیری ولی سنگین برای به کار بردن.</p>
+<p dir='rtl'>حال می توانید برای تفریح مشغول نوشتن برنامه ی های مختلف با آن شوید.</p>
+<p dir='rtl'>و یا یک اجرا کننده برین فاک را با یک زبان دیگر پیاده سازی کنید.</p>
+<p dir='rtl'>و یا اگر خیلی دوست داشتید یک اجرا کننده ی برین فاک با برین فاک بنویسید!!</p>
diff --git a/fa-ir/brainfuck-fa.html.markdown b/fa-ir/brainfuck-fa.html.markdown
deleted file mode 100644
index ef2bcba3..00000000
--- a/fa-ir/brainfuck-fa.html.markdown
+++ /dev/null
@@ -1,81 +0,0 @@
----
-language: brainfuck
-contributors:
-    - ["Mohammad Valipour", "https://github.com/mvalipour"]
-lang: fa-ir
----
-
-<p dir='rtl'>برین فاک زبان برنامه نویسی تورینگ کامل بی نهایت ساده ایست که دارای فقط هشت</p>
-<p dir='rtl'>دستور است.</p>
-
-<p dir='rtl'>هر کارکتری به جر کارکتر های زیر در این زبان در نظر گرفته نمیشود.</p>
-
-
-`>` `<` `+` `-` `.` `,` `[` `]`
-
-<p dir='rtl'>برین فاک به صورت یک آرایه ی سی هزار خانه ای کار میکند که در ابتدا تمامی خانه های آن صفر هستند.</p>
-<p dir='rtl'>همچنین یک اشاره گر در این برنامه به خانه ی فعلی اشاره میکند.</p>
-
-<p dir='rtl'>در زیر هشت دستور این زبان شرح داده شده است:</p>
-
-<p dir='rtl'>`+` : یک عدد به خانه ی فعلی اضافه می کند.
-<p dir='rtl'>`-` : یک عدد از خانه ی فعلی کم می کند.  </p>
-<p dir='rtl'>`>` : اشاره گر به خانه ی بعدی میرود -- به راست</p>
-<p dir='rtl'>`<` : اشاره گر به خانه ی قبلی میرود -- به چپ</p>
-<p dir='rtl'>`.` : کارکتر اسکی معادل مقدار خانه ی فعلی را چاپ میکند. -- به عنوان مثال 65 برای A</p>
-<p dir='rtl'>`,` : یک کارکتر را از ورودی خوانده و مقدار آن را در خانه ی فعلی زخیره میکند.</p>
-<p dir='rtl'>`[` : اگر مقدار خانه ی فعلی صفر باشد به محل بسته شدن کروشه جهش میکند. -- و از همه ی دستور های بین آن صرف نظر میشود.</p>
-<p dir='rtl'>در غیر این صورت به دستور بعدی میرود.</p>
-<p dir='rtl'>`]` : اگر مقدار خانه ی فعلی صفر باشد به خانه ی بعدی و در غیر این صورت به محل باز شدن کروشه جهش می کند. -- به عقب</p>
-
-<p dir='rtl'>دو علامت کروشه امکان ایجاد حلقه را فراهم میکنند.</p>
-
-<p dir='rtl'>در اینجا یک برنامه ی ساره برین فاک را مشاهده میکنید.</p>
-
-```
-++++++ [ > ++++++++++ < - ] > +++++ .
-```
-
-<p dir='rtl'>این برنامه کارکتر A را بر روی خروجی چاپ میکند.</p>
-<p dir='rtl'>در این برنامه خانه ی اول به عنوان متغیر حلقه و خانه ی دوم برای مقدار عددی A</p>
-<p dir='rtl'>ابتدا عدد شش در خانه ی اول ایجاد شده. سپس  برنامه  وارد یک حلقه میشود که در هر بار </p>
-<p dir='rtl'>تکرار آن اشاره گر به خانه ی دوم رفته و ده بار به خانه ی فعلی اضافه می کند.</p>
-<p dir='rtl'>-- و در انتهای حلقه به خانه ی اول برگشته تا حلقه کنترل شود</p>
-<p dir='rtl'>بعد از اتمام حلقه به خانه ی دوم میرود و پنج بار به این خانه اضافه کرده و سپس آنرا چاپ میکند.</p>
-
-```
-, [ > + < - ] > .
-```
-
-<p dir='rtl'>در این برنامه ابتدا یک کارکتر از ورودی خوانده می شود. سپس یک حلقه به تعداد بار مقدار</p>
-<p dir='rtl'>عددی کارکتر، یک عدد به خانه ی دوم اضافه می کند. با این کار در واقع برنامه مقدار ورودی را در خانه ی </p>
-<p dir='rtl'>دوم کپی می کند. و در نهایت آن را برروی خروجی چاپ می کند.</p>
-
-<p dir='rtl'>توجه داشته باشید که ردر بالا فواصل بین دستور ها فقط برای خوانایی بیشتر گذاشته شده اند.</p>
-<p dir='rtl'>در واقع برنامه بالا به شکل زیر صحیح می باشد.</p>
-
-```
-,[>+<-]>.
-```
-
-<p dir='rtl'>حال سعی کنید ببینید که برنامه ی زیر چه کاری انجام می دهد؟</p>
-
-```
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
-```
-
-<p dir='rtl'>این برنامه دو عدد را از ورودی خوانده و با هم ضرب می کند.</p>
-
-<p dir='rtl'>ابتدا دو عدد از ورودی خوانده می شوند. سپس حلقه ی بیرونی بر روی خانه شماره یک شروع میشود.</p>
-<p dir='rtl'>و درون آن حلقه ی دیگری بر روی خانه ی دوم شروع میشود که خانه ی 3 را زیاد میکند.</p>
-<p dir='rtl'>ولی مشکلی که در اینجا به وجود می آید اینست که در پایان حلقه ی دوم مقدار خانه ی 2 صفر شده</p>
-<p dir='rtl'>و مقدار اولیه ی آن از دست رفته است. برای حل این مشکل خانه ی شماره چهار هم زیاد میشود</p>
-<p dir='rtl'>و در پایان حلقه مقدار آن به خانه 2 کپی میشود.</p>
-<p dir='rtl'>در پایان خانه ی شماره 2  حاوی حاصلضرب خواهد بود.</p>
-
-<hr>
-
-<p dir='rtl'>و این همه ی برین فاک بود! خیلی ساده برای یادگیری ولی سنگین برای به کار بردن.</p>
-<p dir='rtl'>حال می توانید برای تفریح مشغول نوشتن برنامه ی های مختلف با آن شوید.</p>
-<p dir='rtl'>و یا یک اجرا کننده برین فاک را با یک زبان دیگر پیاده سازی کنید.</p>
-<p dir='rtl'>و یا اگر خیلی دوست داشتید یک اجرا کننده ی برین فاک با برین فاک بنویسید!!</p>
diff --git a/fr-fr/bf-fr.html.markdown b/fr-fr/bf-fr.html.markdown
new file mode 100644
index 00000000..0fae6032
--- /dev/null
+++ b/fr-fr/bf-fr.html.markdown
@@ -0,0 +1,87 @@
+---
+language: bf
+filename: learnbrainfuck-fr.bf
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Baptiste Fontaine", "http://bfontaine.net"]
+lang: fr-fr
+---
+
+Brainfuck (sans majuscule à part au début d’une phrase) est un langage
+Turing-complet extrêmement simple avec seulement 8 commandes.
+
+```
+Tout caractère en dehors de "><+-.,[]" (en dehors des guillemets) est ignoré.
+
+Brainfuck est représenté par un tableau de 30 000 cellules initialisées à 0 et
+un pointeur de données pointant sur la cellule courante.
+
+Il y a huit commandes :
++ : Incrémente la valeur de la cellule courante de un.
+- : Décrémente la valeur de la cellule courante de un.
+> : Déplace le pointeur de données sur la cellule suivante (à droite).
+< : Déplace le pointeur de données sur la cellule précédente (à gauche).
+. : Affiche la valeur ASCII de la cellule courante (par ex. 65 = 'A').
+, : Lit un caractère et le place dans la cellule courante.
+[ : Si la valeur dans la cellule courante vaut 0, saute au ] correspondant.
+    Sinon, continue avec la commande suivante.
+] : Si la valeur dans la cellule courante vaut 0, continue avec la commande
+    suivante. Sinon, retourne au [ correspondant.
+
+[ et ] forment une boucle « tant que » (« while »). Ils doivent évidemment
+aller par paires.
+
+Regardons quelques programmes simples en brainfuck.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Ce programme affiche la lettre 'A'. Il commence par incrémenter la première
+cellule à 6. Il entre ensuite dans une boucle et se déplace sur la seconde
+cellule. Il l’incrémente 10 fois, retourne sur la première cellule, et la
+décrémente. Cette boucle est exécutée 6 fois (ce qui correspond aux 6
+décrémentations de la première cellule pour la faire atteindre 0, ce qui fait
+sortir de la boucle).
+
+À ce moment-là, nous sommes sur la première cellule, qui a une valeur de 0,
+tandis que la seconde cellule a une valeur de 60. Nous nous déplaçons sur
+celle-ci, l’incrémentons 5 fois, pour une valeur de 65, et affichons sa valeur.
+En ASCII, 65 correspond à 'A' donc le programme affiche 'A' dans le terminal.
+
+, [ > + < - ] > .
+
+Ce programme lit un caractère sur l’entrée standard et le copie dans la
+première cellule. Il commence ensuite une boucle : il bouge sur la seconde
+cellule, incrémente sa valeur, retourne sur la première et décrémente sa
+valeur. Il continue jusqu’à ce que la valeur de la première cellule soit à 0,
+et que la seconde cellule contienne l’ancienne valeur de la première. Comme
+nous sommes sur la première cellule à la fin de la boucle, il bouge sur la
+seconde et affiche sa valeur en ASCII.
+
+Souvenez-vous que les espaces sont uniquement là pour favoriser la lisibilité,
+vous pourriez tout aussi aisément écrire le programme comme ceci :
+
+,[>+<-]>.
+
+Essayez et devinez ce que ce programme fait :
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Ce programme prend deux nombres en entrée, et les multiplie.
+
+Il commence par lire deux entrées, puis commence une boucle externe, qui a une
+condition sur la première cellule. Il bouge ensuite sur la seconde, et commence
+une boucle interne sur celle-ci, en incrémentant la troisième cellule. Il y a
+cependant un problème : à la fin de la boucle interne, la valeur de la seconde
+cellule est à zéro. Dans ce cas, la boucle interne ne fonctionnera pas une
+seconde fois. Pour régler le problème, nous incrémentons aussi la quatrième
+cellule, puis recopions sa valeur dans la seconde cellule.
+À la fin, la troisième cellule contient le résultat de la multiplication.
+```
+
+Et voilà ce qu’est le brainfuck. Pas très dur, hein ? Pour le fun, vous pouvez
+écrire vos propres programmes en brainfuck, ou écrire un interpréteur brainfuck
+dans un autre langage. L’interpréteur est relativement simple à implémenter,
+mais si vous êtes un masochiste, essayez d’écrire un interpréteur brainfuck en…
+brainfuck.
diff --git a/fr-fr/brainfuck-fr.html.markdown b/fr-fr/brainfuck-fr.html.markdown
deleted file mode 100644
index 545e407e..00000000
--- a/fr-fr/brainfuck-fr.html.markdown
+++ /dev/null
@@ -1,87 +0,0 @@
----
-language: brainfuck
-filename: learnbrainfuck-fr.bf
-contributors:
-    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-    - ["Mathias Bynens", "http://mathiasbynens.be/"]
-translators:
-    - ["Baptiste Fontaine", "http://bfontaine.net"]
-lang: fr-fr
----
-
-Brainfuck (sans majuscule à part au début d’une phrase) est un langage
-Turing-complet extrêmement simple avec seulement 8 commandes.
-
-```
-Tout caractère en dehors de "><+-.,[]" (en dehors des guillemets) est ignoré.
-
-Brainfuck est représenté par un tableau de 30 000 cellules initialisées à 0 et
-un pointeur de données pointant sur la cellule courante.
-
-Il y a huit commandes :
-+ : Incrémente la valeur de la cellule courante de un.
-- : Décrémente la valeur de la cellule courante de un.
-> : Déplace le pointeur de données sur la cellule suivante (à droite).
-< : Déplace le pointeur de données sur la cellule précédente (à gauche).
-. : Affiche la valeur ASCII de la cellule courante (par ex. 65 = 'A').
-, : Lit un caractère et le place dans la cellule courante.
-[ : Si la valeur dans la cellule courante vaut 0, saute au ] correspondant.
-    Sinon, continue avec la commande suivante.
-] : Si la valeur dans la cellule courante vaut 0, continue avec la commande
-    suivante. Sinon, retourne au [ correspondant.
-
-[ et ] forment une boucle « tant que » (« while »). Ils doivent évidemment
-aller par paires.
-
-Regardons quelques programmes simples en brainfuck.
-
-++++++ [ > ++++++++++ < - ] > +++++ .
-
-Ce programme affiche la lettre 'A'. Il commence par incrémenter la première
-cellule à 6. Il entre ensuite dans une boucle et se déplace sur la seconde
-cellule. Il l’incrémente 10 fois, retourne sur la première cellule, et la
-décrémente. Cette boucle est exécutée 6 fois (ce qui correspond aux 6
-décrémentations de la première cellule pour la faire atteindre 0, ce qui fait
-sortir de la boucle).
-
-À ce moment-là, nous sommes sur la première cellule, qui a une valeur de 0,
-tandis que la seconde cellule a une valeur de 60. Nous nous déplaçons sur
-celle-ci, l’incrémentons 5 fois, pour une valeur de 65, et affichons sa valeur.
-En ASCII, 65 correspond à 'A' donc le programme affiche 'A' dans le terminal.
-
-, [ > + < - ] > .
-
-Ce programme lit un caractère sur l’entrée standard et le copie dans la
-première cellule. Il commence ensuite une boucle : il bouge sur la seconde
-cellule, incrémente sa valeur, retourne sur la première et décrémente sa
-valeur. Il continue jusqu’à ce que la valeur de la première cellule soit à 0,
-et que la seconde cellule contienne l’ancienne valeur de la première. Comme
-nous sommes sur la première cellule à la fin de la boucle, il bouge sur la
-seconde et affiche sa valeur en ASCII.
-
-Souvenez-vous que les espaces sont uniquement là pour favoriser la lisibilité,
-vous pourriez tout aussi aisément écrire le programme comme ceci :
-
-,[>+<-]>.
-
-Essayez et devinez ce que ce programme fait :
-
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
-
-Ce programme prend deux nombres en entrée, et les multiplie.
-
-Il commence par lire deux entrées, puis commence une boucle externe, qui a une
-condition sur la première cellule. Il bouge ensuite sur la seconde, et commence
-une boucle interne sur celle-ci, en incrémentant la troisième cellule. Il y a
-cependant un problème : à la fin de la boucle interne, la valeur de la seconde
-cellule est à zéro. Dans ce cas, la boucle interne ne fonctionnera pas une
-seconde fois. Pour régler le problème, nous incrémentons aussi la quatrième
-cellule, puis recopions sa valeur dans la seconde cellule.
-À la fin, la troisième cellule contient le résultat de la multiplication.
-```
-
-Et voilà ce qu’est le brainfuck. Pas très dur, hein ? Pour le fun, vous pouvez
-écrire vos propres programmes en brainfuck, ou écrire un interpréteur brainfuck
-dans un autre langage. L’interpréteur est relativement simple à implémenter,
-mais si vous êtes un masochiste, essayez d’écrire un interpréteur brainfuck en…
-brainfuck.
diff --git a/it-it/bf-it.html.markdown b/it-it/bf-it.html.markdown
new file mode 100644
index 00000000..a79710d0
--- /dev/null
+++ b/it-it/bf-it.html.markdown
@@ -0,0 +1,92 @@
+---
+language: bf
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Ivan Sala", "http://slavni96.github.io/"]
+    - ["Christian Grasso", "http://chris54721.net"]
+lang: it-it
+---
+
+Brainfuck è un linguaggio di programmazione
+[Turing equivalente](https://it.wikipedia.org/wiki/Turing_equivalenza)
+estremamente minimale, composto da solo 8 comandi.
+
+Puoi provarlo nel tuo browser utilizzando
+[brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+```
+
+Qualsiasi carattere diverso da "><+-.,[]" (escludendo gli apici)
+viene ignorato.
+Branfuck è caratterizzato da un array di 30,000 celle inizializzate a zero
+e da un puntatore che punta alla cella corrente.
+
+Vi sono otto comandi:
++ : Incrementa il valore della cella attuale di uno.
+- : Decrementa il valore della cella attuale di uno.
+> : Sposta il puntatore sulla cella seguente (sulla destra).
+< : Sposta il puntatore sulla cella precendete (sulla sinistra).
+. : Stampa il valore ASCII della cella corrente. (es. 65 = 'A')
+, : Legge un singolo carattere come input e lo salva nella cella corrente.
+[ : Se il valore della cella corrente è zero, prosegue fino alla ] corrispondente.
+    Altrimenti, passa alla prossima istruzione.
+] : Se il valore della cella corrente è zero, passa alla prossima istruzione.
+    Altrimenti, torna indietro fino alla [ corrispondente.
+
+[ e ] formano un ciclo while. Ovviamente dovranno essere bilanciati.
+(Ad ogni [ dovrà corrispondere una ])
+
+Ecco alcuni semplici esempi di programmi scritti in Brainfuck:
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Questo programma stampa in output la lettera 'A'. Prima di tutto, incrementa
+la cella #1 fino al valore 6. La cella #1 verrà utilizzata per il ciclo.
+Poi, entra nel ciclo ([) e si sposta alla cella #2. Incrementa la cella #2 10
+volte, torna alla cella #1, e decrementa quest'ultima.
+Il ciclo si ripete 6 volte (la cella #1 viene decrementata 6 volte prima di
+raggiungere lo 0, quindi prosegue oltre la corrispondente ]).
+
+A questo punto, siamo sulla cella #1, che ha valore 0, mentre la cella #2 ha
+valore 60. Ci spostiamo sulla cella #2, la incrementiamo per 5 volte, ottenendo
+il valore 65, quindi stampiamo il valore della cella #2.
+Il valore 65 equivale ad 'A' in ASCII, per cui viene stampato 'A' nel terminale.
+
+
+, [ > + < - ] > .
+
+Questo programma legge un carattere come input dall'utente, quindi salva il
+carattere nella cella #1. Dopodichè entra in un ciclo. Si sposta alla cella #2,
+incrementa quest'ultima, torna alla cella #1, e decrementa quest'ultima.
+Il ciclo continua fino a quando la cella #1 diventa 0, e quindi la cella #2
+avrà il valore iniziale della cella #1. Infine, visto che ci troviamo sulla
+cella #1 alla fine del ciclo, si sposta sulla cella #2 e stampa il valore in
+ASCII.
+
+Gli spazi nel codice sovrastante sono presenti solo a scopo di ottenere
+una maggiore leggibilità. Lo stesso programma poteva essere scritto senza spazi:
+
+,[>+<-]>.
+
+Proviamo, adesso, a capire cosa fa invece questo programma:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Il programma legge 2 numeri come input dall'utente, e li moltiplica.
+
+Innanzitutto, legge in input i due numeri. Poi entra nel ciclo più esterno
+basandosi sulla cella #1. Quindi si sposta sulla cella #2, e inizia il ciclo
+più interno basandosi sul valore della cella #2, incrementando la cella #3.
+Arrivati a questo punto abbiamo un problema: alla fine del ciclo interno
+la cella #2 avrà valore 0. Ciò impedirà di eseguire nuovamente il ciclo interno.
+Per ovviare a questo problema, incrementiamo anche la cella #4, e copiamo il
+valore di quest'ultima nella cella #2.
+Il risultato sarà infine contenuto nella cella #3.
+```
+
+E questo è brainfuck. Non è così difficile, eh? Se vuoi, ora puoi scrivere per
+divertimento altri programmi in brainfuck, oppure scrivere un interprete
+brainfuck in un altro linguaggio. L'interprete è abbastanza semplice da
+implementare, ma se sei veramente masochista, prova ad implementare un interprete brainfuck... in brainfuck.
diff --git a/it-it/brainfuck-it.html.markdown b/it-it/brainfuck-it.html.markdown
deleted file mode 100644
index 08d2ede9..00000000
--- a/it-it/brainfuck-it.html.markdown
+++ /dev/null
@@ -1,92 +0,0 @@
----
-language: brainfuck
-contributors:
-    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-    - ["Mathias Bynens", "http://mathiasbynens.be/"]
-translators:
-    - ["Ivan Sala", "http://slavni96.github.io/"]
-    - ["Christian Grasso", "http://chris54721.net"]
-lang: it-it
----
-
-Brainfuck è un linguaggio di programmazione
-[Turing equivalente](https://it.wikipedia.org/wiki/Turing_equivalenza)
-estremamente minimale, composto da solo 8 comandi.
-
-Puoi provarlo nel tuo browser utilizzando
-[brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
-
-```
-
-Qualsiasi carattere diverso da "><+-.,[]" (escludendo gli apici)
-viene ignorato.
-Branfuck è caratterizzato da un array di 30,000 celle inizializzate a zero
-e da un puntatore che punta alla cella corrente.
-
-Vi sono otto comandi:
-+ : Incrementa il valore della cella attuale di uno.
-- : Decrementa il valore della cella attuale di uno.
-> : Sposta il puntatore sulla cella seguente (sulla destra).
-< : Sposta il puntatore sulla cella precendete (sulla sinistra).
-. : Stampa il valore ASCII della cella corrente. (es. 65 = 'A')
-, : Legge un singolo carattere come input e lo salva nella cella corrente.
-[ : Se il valore della cella corrente è zero, prosegue fino alla ] corrispondente.
-    Altrimenti, passa alla prossima istruzione.
-] : Se il valore della cella corrente è zero, passa alla prossima istruzione.
-    Altrimenti, torna indietro fino alla [ corrispondente.
-
-[ e ] formano un ciclo while. Ovviamente dovranno essere bilanciati.
-(Ad ogni [ dovrà corrispondere una ])
-
-Ecco alcuni semplici esempi di programmi scritti in Brainfuck:
-
-++++++ [ > ++++++++++ < - ] > +++++ .
-
-Questo programma stampa in output la lettera 'A'. Prima di tutto, incrementa
-la cella #1 fino al valore 6. La cella #1 verrà utilizzata per il ciclo.
-Poi, entra nel ciclo ([) e si sposta alla cella #2. Incrementa la cella #2 10
-volte, torna alla cella #1, e decrementa quest'ultima.
-Il ciclo si ripete 6 volte (la cella #1 viene decrementata 6 volte prima di
-raggiungere lo 0, quindi prosegue oltre la corrispondente ]).
-
-A questo punto, siamo sulla cella #1, che ha valore 0, mentre la cella #2 ha
-valore 60. Ci spostiamo sulla cella #2, la incrementiamo per 5 volte, ottenendo
-il valore 65, quindi stampiamo il valore della cella #2.
-Il valore 65 equivale ad 'A' in ASCII, per cui viene stampato 'A' nel terminale.
-
-
-, [ > + < - ] > .
-
-Questo programma legge un carattere come input dall'utente, quindi salva il
-carattere nella cella #1. Dopodichè entra in un ciclo. Si sposta alla cella #2,
-incrementa quest'ultima, torna alla cella #1, e decrementa quest'ultima.
-Il ciclo continua fino a quando la cella #1 diventa 0, e quindi la cella #2
-avrà il valore iniziale della cella #1. Infine, visto che ci troviamo sulla
-cella #1 alla fine del ciclo, si sposta sulla cella #2 e stampa il valore in
-ASCII.
-
-Gli spazi nel codice sovrastante sono presenti solo a scopo di ottenere
-una maggiore leggibilità. Lo stesso programma poteva essere scritto senza spazi:
-
-,[>+<-]>.
-
-Proviamo, adesso, a capire cosa fa invece questo programma:
-
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
-
-Il programma legge 2 numeri come input dall'utente, e li moltiplica.
-
-Innanzitutto, legge in input i due numeri. Poi entra nel ciclo più esterno
-basandosi sulla cella #1. Quindi si sposta sulla cella #2, e inizia il ciclo
-più interno basandosi sul valore della cella #2, incrementando la cella #3.
-Arrivati a questo punto abbiamo un problema: alla fine del ciclo interno
-la cella #2 avrà valore 0. Ciò impedirà di eseguire nuovamente il ciclo interno.
-Per ovviare a questo problema, incrementiamo anche la cella #4, e copiamo il
-valore di quest'ultima nella cella #2.
-Il risultato sarà infine contenuto nella cella #3.
-```
-
-E questo è brainfuck. Non è così difficile, eh? Se vuoi, ora puoi scrivere per
-divertimento altri programmi in brainfuck, oppure scrivere un interprete
-brainfuck in un altro linguaggio. L'interprete è abbastanza semplice da
-implementare, ma se sei veramente masochista, prova ad implementare un interprete brainfuck... in brainfuck.
diff --git a/ko-kr/bf-kr.html.markdown b/ko-kr/bf-kr.html.markdown
new file mode 100644
index 00000000..3d366d7c
--- /dev/null
+++ b/ko-kr/bf-kr.html.markdown
@@ -0,0 +1,84 @@
+---
+language: bf
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["JongChan Choi", "http://0xABCDEF.com/"]
+    - ["Peter Lee", "http://peterjlee.com/"]
+lang: ko-kr
+---
+
+Brainfuck(문장을 시작하는 단어가 아닌이상 첫글자는 대문자를 사용하지 않습니다)은
+여덟가지 명령어만으로 튜링-완전한 최소주의 프로그래밍 언어입니다.
+
+```
+"><+-.,[]" 이외의 문자들은 무시됩니다. (쌍따옴표는 제외)
+
+브레인퍽은 30,000 칸 짜리의 0으로 초기화된 배열과,
+현재 칸을 가르키는 포인터로 표현됩니다.
+
+여덟가지의 명령어는 다음과 같습니다:
++ : 포인터가 가르키는 현재 칸의 값을 1 증가시킵니다.
+- : 포인터가 가르키는 현재 칸의 값을 1 감소시킵니다.
+> : 포인터가 다음 칸(오른쪽 칸)을 가르키도록 이동시킵니다.
+< : 포인터가 이전 칸(왼쪽 칸)을 가르키도록 이동시킵니다.
+. : 현재 칸의 값을 ASCII 문자로 출력합니다. (즉, 65 = 'A')
+, : 하나의 문자를 입력받고 그 값을 현재 칸에 대입합니다.
+[ : 현재 칸의 값이 0이면 짝이 맞는 ] 명령으로 넘어갑니다.
+    0이 아니면 다음 명령어로 넘어갑니다.
+] : 현재 칸의 값이 0이면 다음 명령어로 넘어갑니다.
+    0이 아니면 짝이 맞는 [ 명령으로 다시 돌아갑니다.
+
+[이랑 ]은 while 루프를 만들어냅니다. 무조건, 짝이 맞아야 합니다.
+
+몇가지 간단한 브레인퍽 프로그램을 보겠습니다.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+이 프로그램은 문자 'A'를 출력합니다. 처음에는, 반복할 횟수를 정하기 위한 값을
+만들기 위해 첫번째 칸의 값을 6으로 증가시킵니다. 그리고 루프로 들어가서([)
+두번째 칸으로 넘어갑니다. 루프 안에서는 두번째 칸의 값을 10 증가시키고,
+다시 첫번째 칸으로 넘어가서 값을 1 감소시킵니다. 이 루프는 여섯번 돕니다.
+(첫번째 칸의 값을 6번 감소시켜서 0이 될 때 까지는 ] 명령을 만날 때마다
+루프의 시작 지점으로 돌아갑니다)
+
+이 시점에서, 두번째 칸의 값은 60이고, 포인터는 값이 0인 첫번째 칸에 위치합니다.
+여기서 두번째 칸으로 넘어간 다음 값을 5 증가시키면 두번째 칸의 값이 65가 되고,
+65는 문자 'A'에 대응하는 아스키 코드이기 때문에, 두번째 칸의 값을 출력하면
+터미널에 'A'가 출력됩니다.
+
+, [ > + < - ] > .
+
+이 프로그램은 사용자로부터 문자 하나를 입력받아 첫번째 칸에 집어넣습니다.
+그리고 루프에 들어가서, 두번째 칸으로 넘어가 값을 한 번 증가시킨 다음,
+다시 첫번째 칸으로 넘어가서 값을 한 번 감소시킵니다.
+이는 첫번째 칸의 값이 0이 될 때까지 지속되며,
+두번째 칸은 첫번째 칸이 갖고있던 값을 가지게 됩니다.
+루프가 종료되면 포인터는 첫번째 칸을 가르키기 때문에 두번째 칸으로 넘어가고,
+해당 아스키 코드에 대응하는 문자를 출력합니다.
+
+또한 공백문자는 순전히 가독성을 위해서 작성되었다는 것을 기억하세요.
+다음과 같이 작성해도 똑같이 돌아갑니다:
+
+,[>+<-]>.
+
+한 번 돌려보고 아래의 프로그램이 실제로 무슨 일을 하는지 맞춰보세요:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+이 프로그램은 두 개의 숫자를 입력받은 뒤, 그 둘을 곱합니다.
+
+위 코드는 일단 두 번의 입력을 받고, 첫번째 칸의 값만큼 바깥 루프를 돕니다.
+그리고 루프 안에서 다시 두번째 칸의 값만큼 안쪽의 루프를 돕니다.
+그리고 그 루프에서는 세번째 칸의 값을 증가시키는데, 문제가 하나 있습니다:
+내부 루프가 한 번 끝나게 되면 두번째 칸의 값은 0이 됩니다.
+그럼 다시 바깥 루프를 돌 때에 안쪽의 루프를 돌지 않게 되는데, 이를 해결하려면
+네번째 칸의 값도 같이 증가시킨 다음, 그 값을 두번째 칸으로 옮기면 됩니다.
+그러면 세번째 칸에 곱셈의 결과가 남습니다.
+```
+
+여기까지 브레인퍽이었습니다. 참 쉽죠?
+재미삼아 브레인퍽 프로그램이나 다른 언어로 브레인퍽 인터프리터를 작성해보세요.
+인터프리터 구현은 간단한 편인데,
+사서 고생하는 것을 즐기는 편이라면 한 번 작성해보세요… 브레인퍽으로.
diff --git a/ko-kr/brainfuck-kr.html.markdown b/ko-kr/brainfuck-kr.html.markdown
deleted file mode 100644
index c2e4341f..00000000
--- a/ko-kr/brainfuck-kr.html.markdown
+++ /dev/null
@@ -1,84 +0,0 @@
----
-language: brainfuck
-contributors:
-    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-    - ["Mathias Bynens", "http://mathiasbynens.be/"]
-translators:
-    - ["JongChan Choi", "http://0xABCDEF.com/"]
-    - ["Peter Lee", "http://peterjlee.com/"]
-lang: ko-kr
----
-
-Brainfuck(문장을 시작하는 단어가 아닌이상 첫글자는 대문자를 사용하지 않습니다)은
-여덟가지 명령어만으로 튜링-완전한 최소주의 프로그래밍 언어입니다.
-
-```
-"><+-.,[]" 이외의 문자들은 무시됩니다. (쌍따옴표는 제외)
-
-브레인퍽은 30,000 칸 짜리의 0으로 초기화된 배열과,
-현재 칸을 가르키는 포인터로 표현됩니다.
-
-여덟가지의 명령어는 다음과 같습니다:
-+ : 포인터가 가르키는 현재 칸의 값을 1 증가시킵니다.
-- : 포인터가 가르키는 현재 칸의 값을 1 감소시킵니다.
-> : 포인터가 다음 칸(오른쪽 칸)을 가르키도록 이동시킵니다.
-< : 포인터가 이전 칸(왼쪽 칸)을 가르키도록 이동시킵니다.
-. : 현재 칸의 값을 ASCII 문자로 출력합니다. (즉, 65 = 'A')
-, : 하나의 문자를 입력받고 그 값을 현재 칸에 대입합니다.
-[ : 현재 칸의 값이 0이면 짝이 맞는 ] 명령으로 넘어갑니다.
-    0이 아니면 다음 명령어로 넘어갑니다.
-] : 현재 칸의 값이 0이면 다음 명령어로 넘어갑니다.
-    0이 아니면 짝이 맞는 [ 명령으로 다시 돌아갑니다.
-
-[이랑 ]은 while 루프를 만들어냅니다. 무조건, 짝이 맞아야 합니다.
-
-몇가지 간단한 브레인퍽 프로그램을 보겠습니다.
-
-++++++ [ > ++++++++++ < - ] > +++++ .
-
-이 프로그램은 문자 'A'를 출력합니다. 처음에는, 반복할 횟수를 정하기 위한 값을
-만들기 위해 첫번째 칸의 값을 6으로 증가시킵니다. 그리고 루프로 들어가서([)
-두번째 칸으로 넘어갑니다. 루프 안에서는 두번째 칸의 값을 10 증가시키고,
-다시 첫번째 칸으로 넘어가서 값을 1 감소시킵니다. 이 루프는 여섯번 돕니다.
-(첫번째 칸의 값을 6번 감소시켜서 0이 될 때 까지는 ] 명령을 만날 때마다
-루프의 시작 지점으로 돌아갑니다)
-
-이 시점에서, 두번째 칸의 값은 60이고, 포인터는 값이 0인 첫번째 칸에 위치합니다.
-여기서 두번째 칸으로 넘어간 다음 값을 5 증가시키면 두번째 칸의 값이 65가 되고,
-65는 문자 'A'에 대응하는 아스키 코드이기 때문에, 두번째 칸의 값을 출력하면
-터미널에 'A'가 출력됩니다.
-
-, [ > + < - ] > .
-
-이 프로그램은 사용자로부터 문자 하나를 입력받아 첫번째 칸에 집어넣습니다.
-그리고 루프에 들어가서, 두번째 칸으로 넘어가 값을 한 번 증가시킨 다음,
-다시 첫번째 칸으로 넘어가서 값을 한 번 감소시킵니다.
-이는 첫번째 칸의 값이 0이 될 때까지 지속되며,
-두번째 칸은 첫번째 칸이 갖고있던 값을 가지게 됩니다.
-루프가 종료되면 포인터는 첫번째 칸을 가르키기 때문에 두번째 칸으로 넘어가고,
-해당 아스키 코드에 대응하는 문자를 출력합니다.
-
-또한 공백문자는 순전히 가독성을 위해서 작성되었다는 것을 기억하세요.
-다음과 같이 작성해도 똑같이 돌아갑니다:
-
-,[>+<-]>.
-
-한 번 돌려보고 아래의 프로그램이 실제로 무슨 일을 하는지 맞춰보세요:
-
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
-
-이 프로그램은 두 개의 숫자를 입력받은 뒤, 그 둘을 곱합니다.
-
-위 코드는 일단 두 번의 입력을 받고, 첫번째 칸의 값만큼 바깥 루프를 돕니다.
-그리고 루프 안에서 다시 두번째 칸의 값만큼 안쪽의 루프를 돕니다.
-그리고 그 루프에서는 세번째 칸의 값을 증가시키는데, 문제가 하나 있습니다:
-내부 루프가 한 번 끝나게 되면 두번째 칸의 값은 0이 됩니다.
-그럼 다시 바깥 루프를 돌 때에 안쪽의 루프를 돌지 않게 되는데, 이를 해결하려면
-네번째 칸의 값도 같이 증가시킨 다음, 그 값을 두번째 칸으로 옮기면 됩니다.
-그러면 세번째 칸에 곱셈의 결과가 남습니다.
-```
-
-여기까지 브레인퍽이었습니다. 참 쉽죠?
-재미삼아 브레인퍽 프로그램이나 다른 언어로 브레인퍽 인터프리터를 작성해보세요.
-인터프리터 구현은 간단한 편인데,
-사서 고생하는 것을 즐기는 편이라면 한 번 작성해보세요… 브레인퍽으로.
diff --git a/nl-nl/bf.html.markdown b/nl-nl/bf.html.markdown
new file mode 100644
index 00000000..016e2ba2
--- /dev/null
+++ b/nl-nl/bf.html.markdown
@@ -0,0 +1,86 @@
+---
+language: bf
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Jelle Besseling", "https://github.com/Jell-E"]
+lang: nl-nl
+---
+
+Brainfuck (schrijf je niet met een hoofdletter behalve aan het begin van een
+zin) is een extreem
+minimalistische Turing-complete programmeertaal met maar acht commando's.
+
+```
+Elk karakter behalve "><+-.,[]" (en de quotes) wordt genegeerd.
+
+Brainfuck wordt gerepresenteerd door een array met 30.000 cellen die initieel
+gevuld is met nullen en een pointer die wijst naar de huidige cel.
+
+Dit zijn de acht commando's:
++ : Verhoog de huidige cell met 1.
+- : Verminder de huidige cell met 1.
+> : Beweeg de pointer naar de volgende cell (één naar rechts).
+< : Beweeg de pointer naar de vorige cell (één naar links).
+. : Print de huidige cell als een ASCII karakter(d.w.z. 65 = 'A').
+, : Lees een karakter in de huidige cell.
+[ : Als de huidige cell nul is ga dan naar de bijbehorende ] .
+    Als het geen nul is, ga dan gewoon verder.
+] : Als de huidige cell nul is ga dan gewoon verder.
+    Als het geen nul is, ga dan terug naar de bijbehorende [ .
+
+[ en ] maken een while loop. Ze moeten uiteraard wel gebalanceerd zijn
+
+Laten we een kijkje nemen naar een paar brainfuck programma's.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Dit programma print het karakter 'A'. Eerst verhoogt het cell #1 tot 6.
+Cell #1 wordt gebruikt om te loopen. Dan begint het de loop ([) en gaat
+naar cell #2. Het verhoogt cell #2 tien keer, gaat terug naar cell #1, en
+verlaagt cell #1. Deze loop gebeurt zes keer (na zes keer staat cell #1
+weer op nul, waarna het doorgaat naar het einde van de loop (]) en
+verder gaat).
+
+De pointer staat nu weer op cell #1, deze heeft een waarde van 0, en cell #2
+heeft een waarde van 60. > beweegt de pointer naar cell #2, daarna verhoogt
+het de cell vijf keer, waardoor het een waarde van 65 bevat, en print dan
+de waarde van cell #2. 65 is 'A' in ASCII, dus 'A' wordt geprint in de terminal.
+
+
+, [ > + < - ] > .
+
+Dit programma leest een karakter van de gebruiker in put en kopieert dat
+karakter in cel #1. Dan start de loop. Ga naar cel #2, verhoog de waarde in
+cel #2, ga terug naar cel #1, en verklein de waarde in cel #1. Dit gaat door
+totdat cel #1 nul is en cel #2 de oude waarde heeft van cell #1. Omdat we
+op cel #1 staan verplaatst > de pointer één naar rechts en . print het
+karakter in cel #2.
+
+Houd wel in gedachten dat de spaties alleen zijn voor leesbaarheid, je kan het
+bovenstaande programma net zo goed schrijven als:
+
+,[>+<-]>.
+
+Probeer maar eens te bedenken wat het volgende programma doet:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Dit programma neemt twee getallen als input, en vermenigvuldigt ze.
+
+In het begin leest het twee karakters in cel #1 en #2. Dan start het de
+buitenste loop, met als teller cel #1. Het beweegt naar cel #2, dan start het
+de binnenste loop met als teller cel #2, daar verhoogd het cel #3. Maar
+dan is er een probleem als cel #2 nul wordt aan het einde van de binnenste loop.
+Om dit op te lossen wordt ook cel #4 verhoogd naar het oorspronkelijke getal
+uit cel #2 en daarna wordt cel #4 weer gekopieerd naar cell #2.
+Het resultaat komt in cel #3 te staan.
+```
+
+En dat is dan brainfuck. Niet heel moeilijk, toch? Je kan zelf voor de lol
+brainfuck programma's gaan schrijven, of je kan een interpreter schrijven
+voor brainfuck in een andere taal. Het is namelijk redelijk makkelijk om te
+implementeren aangezien brainfuck maar acht commando's heeft. En als je een
+masochist bent kan je ook nog proberen om brainfuck te implementeren… in
+brainfuck.
diff --git a/nl-nl/brainfuck-nl.html.markdown b/nl-nl/brainfuck-nl.html.markdown
deleted file mode 100644
index 6062b24c..00000000
--- a/nl-nl/brainfuck-nl.html.markdown
+++ /dev/null
@@ -1,86 +0,0 @@
----
-language: brainfuck
-contributors:
-    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-    - ["Mathias Bynens", "http://mathiasbynens.be/"]
-translators:
-    - ["Jelle Besseling", "https://github.com/Jell-E"]
-lang: nl-nl
----
-
-Brainfuck (schrijf je niet met een hoofdletter behalve aan het begin van een
-zin) is een extreem
-minimalistische Turing-complete programmeertaal met maar acht commando's.
-
-```
-Elk karakter behalve "><+-.,[]" (en de quotes) wordt genegeerd.
-
-Brainfuck wordt gerepresenteerd door een array met 30.000 cellen die initieel
-gevuld is met nullen en een pointer die wijst naar de huidige cel.
-
-Dit zijn de acht commando's:
-+ : Verhoog de huidige cell met 1.
-- : Verminder de huidige cell met 1.
-> : Beweeg de pointer naar de volgende cell (één naar rechts).
-< : Beweeg de pointer naar de vorige cell (één naar links).
-. : Print de huidige cell als een ASCII karakter(d.w.z. 65 = 'A').
-, : Lees een karakter in de huidige cell.
-[ : Als de huidige cell nul is ga dan naar de bijbehorende ] .
-    Als het geen nul is, ga dan gewoon verder.
-] : Als de huidige cell nul is ga dan gewoon verder.
-    Als het geen nul is, ga dan terug naar de bijbehorende [ .
-
-[ en ] maken een while loop. Ze moeten uiteraard wel gebalanceerd zijn
-
-Laten we een kijkje nemen naar een paar brainfuck programma's.
-
-++++++ [ > ++++++++++ < - ] > +++++ .
-
-Dit programma print het karakter 'A'. Eerst verhoogt het cell #1 tot 6.
-Cell #1 wordt gebruikt om te loopen. Dan begint het de loop ([) en gaat
-naar cell #2. Het verhoogt cell #2 tien keer, gaat terug naar cell #1, en
-verlaagt cell #1. Deze loop gebeurt zes keer (na zes keer staat cell #1
-weer op nul, waarna het doorgaat naar het einde van de loop (]) en
-verder gaat).
-
-De pointer staat nu weer op cell #1, deze heeft een waarde van 0, en cell #2
-heeft een waarde van 60. > beweegt de pointer naar cell #2, daarna verhoogt
-het de cell vijf keer, waardoor het een waarde van 65 bevat, en print dan
-de waarde van cell #2. 65 is 'A' in ASCII, dus 'A' wordt geprint in de terminal.
-
-
-, [ > + < - ] > .
-
-Dit programma leest een karakter van de gebruiker in put en kopieert dat
-karakter in cel #1. Dan start de loop. Ga naar cel #2, verhoog de waarde in
-cel #2, ga terug naar cel #1, en verklein de waarde in cel #1. Dit gaat door
-totdat cel #1 nul is en cel #2 de oude waarde heeft van cell #1. Omdat we
-op cel #1 staan verplaatst > de pointer één naar rechts en . print het
-karakter in cel #2.
-
-Houd wel in gedachten dat de spaties alleen zijn voor leesbaarheid, je kan het
-bovenstaande programma net zo goed schrijven als:
-
-,[>+<-]>.
-
-Probeer maar eens te bedenken wat het volgende programma doet:
-
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
-
-Dit programma neemt twee getallen als input, en vermenigvuldigt ze.
-
-In het begin leest het twee karakters in cel #1 en #2. Dan start het de
-buitenste loop, met als teller cel #1. Het beweegt naar cel #2, dan start het
-de binnenste loop met als teller cel #2, daar verhoogd het cel #3. Maar
-dan is er een probleem als cel #2 nul wordt aan het einde van de binnenste loop.
-Om dit op te lossen wordt ook cel #4 verhoogd naar het oorspronkelijke getal
-uit cel #2 en daarna wordt cel #4 weer gekopieerd naar cell #2.
-Het resultaat komt in cel #3 te staan.
-```
-
-En dat is dan brainfuck. Niet heel moeilijk, toch? Je kan zelf voor de lol
-brainfuck programma's gaan schrijven, of je kan een interpreter schrijven
-voor brainfuck in een andere taal. Het is namelijk redelijk makkelijk om te
-implementeren aangezien brainfuck maar acht commando's heeft. En als je een
-masochist bent kan je ook nog proberen om brainfuck te implementeren… in
-brainfuck.
diff --git a/pl-pl/bf-pl.html.markdown b/pl-pl/bf-pl.html.markdown
new file mode 100644
index 00000000..801f1a9a
--- /dev/null
+++ b/pl-pl/bf-pl.html.markdown
@@ -0,0 +1,93 @@
+---
+language: bf
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Jakub Młokosiewicz", "https://github.com/hckr"]
+lang: pl-pl
+---
+
+Brainfuck (pisane małymi literami, za wyjątkiem początku zdania) jest bardzo 
+minimalistycznym, kompletnym w sensie Turinga, językiem programowania.
+Zawiera zaledwie 8 poleceń.
+
+Możesz przetesotwać brainfucka w swojej przeglądarce, korzystając z narzędzia 
+[brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+```
+Wszystkie znaki oprócz "><+-.,[]" (wyłączając znaki zapytania) są ignorowane.
+
+Pamięć w brainfucku jest reprezentowana przez tablicę 30.000 komórek
+zainicjalizowanych zerami, ze wskaźnikiem pokazującym na aktualną komórkę.
+
+Oto osiem poleceń brainfucka:
++ : inkrementuje (zwiększa o jeden) wartość aktualnie wskazywanej komórki
+- : dekrementuje (zmniejsza o jeden) wartość aktualnie wskazywanej komórki
+> : przesuwa wskaźnik na następną komórkę (w prawo)
+< : przesuwa wskaźnik na poprzednią komórkę (w lewo)
+. : wyświetla wartość bieżącej komórki (w formie znaku ASCII, np. 65 = 'A')
+, : wczytuje (jeden) znak z wejścia do bieżącej komórki
+    (konkretnie jego numer z tabeli ASCII)
+[ : jeśli wartość w bieżącej komórce jest rózna zero, przechodzi do
+    odpowiadającego ]; w przeciwnym wypdaku przechodzi do następnej instrukcji
+] : Jeśli wartość w bieżącej komórce jest rózna od zera, przechodzi do
+    następnej instrukcji; w przeciwnym wypdaku przechodzi do odpowiadającego [
+
+[ i ] oznaczają pętlę while. Oczywiście każda pętla rozpoczęta [
+musi być zakończona ].
+
+Zobaczmy kilka prostych programów w brainfucku.
+
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Ten program wypisuje literę 'A'. Najpierw zwiększa wartość komórki #1 do 6.
+Komórka #1 będzie wykorzystana w pętli. Następnie program wchodzi w pętlę ([)
+i przechodzi do komórki #2. Pętla wykonuje się sześć razy (komórka #1 jest
+dekrementowana sześć razy, nim osiągnie wartość zero, kiedy to program
+przechodzi do odpowiadającego ] i wykonuje kolejne instrukcje).
+
+W tym momencie wskaźnik pokazuje na komórkę #1, mającą wartość 0, podczas gdy
+komórka #2 ma wartość 60. Przesuwamy wskaźnik na komórkę #2, inkrementujemy ją
+pięć razy, uzyskując wartość 65. Następnie wyświetlamy wartość komórki #2.
+65 to 'A' w tabeli ASCII, więc właśnie ten znak jest wypisany na konsolę.
+
+
+, [ > + < - ] > .
+
+Ten program wczytuje znak z wejścia i umieszcza jego kod ASCII w komórce #1.
+Następnie zaczyna się pętla, w której znajdują się następujące instrukcje: 
+przesunięcie wskaźnika na komórkę #2, inkrementacja wartości komóri #2,
+powrót do komórki #1 i dekrementacja wartości komórki #1. Instrukcje pętli
+wykonują się aż wartość komórki #1 osiągnie zero, a komórka #2 osiągnie
+poprednią wartość komórki #1. Ponieważ na końcu pętli wskaźnik pokazuje na
+komórkę #1, po pętli następuje instrukcja przejścia do komórki #2 i wysłanie
+jej wartości (w formie znaku ASCII) na wyjście.
+
+Zauważ, że odstępy służą wyłącznie poprawie czytelności.
+Równie dobrze można powyższy program zapisać tak:
+
+,[>+<-]>.
+
+
+Spróbuj odgadnąć, co robi poniższy program:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Ten program pobiera z wejścia dwie liczby i je mnoży.
+
+Po wczytaniu dwóch wejść (do komórek #1 i #2) następuje pętla zewnętrzna,
+warunkowana wartością komórki #1. Następnie program przechodzi do komórki #2
+i rozpoczyna pętlę wewnętrzną z warunkiem zakończenia w komórce #2,
+inkrementującą komórkę #3. Tu jednak pojawia się problem: w chwili zakończenia
+wewnętrznej pętli komórka #2 ma wartość zero. W takim razie wewętrzna pętla
+nie wywoła się następny raz. Aby rozwiązać ten problem, inkrementujemy także
+wartość komórki #4, a następnie kopiujemy jej wartość do komórki #2.
+Ostatecznie wynik działania znajduje się w komórce #3.
+```
+
+I to właśnie jest brainfuck. Nie taki trudny, co? W ramach rozrywki możesz
+napisać własne programy w brainfucku. Możesz też napisać interpreter brainfucka
+w innym języku. Implementacja interpretera to dość proste zadanie. Jeśli
+jesteś masochistą, spróbuj napisać interpreter brainfucka w... brainfucku.
diff --git a/pl-pl/brainfuck-pl.html.markdown b/pl-pl/brainfuck-pl.html.markdown
deleted file mode 100644
index 69d814c4..00000000
--- a/pl-pl/brainfuck-pl.html.markdown
+++ /dev/null
@@ -1,93 +0,0 @@
----
-language: brainfuck
-contributors:
-    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-    - ["Mathias Bynens", "http://mathiasbynens.be/"]
-translators:
-    - ["Jakub Młokosiewicz", "https://github.com/hckr"]
-lang: pl-pl
----
-
-Brainfuck (pisane małymi literami, za wyjątkiem początku zdania) jest bardzo 
-minimalistycznym, kompletnym w sensie Turinga, językiem programowania.
-Zawiera zaledwie 8 poleceń.
-
-Możesz przetesotwać brainfucka w swojej przeglądarce, korzystając z narzędzia 
-[brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
-
-```
-Wszystkie znaki oprócz "><+-.,[]" (wyłączając znaki zapytania) są ignorowane.
-
-Pamięć w brainfucku jest reprezentowana przez tablicę 30.000 komórek
-zainicjalizowanych zerami, ze wskaźnikiem pokazującym na aktualną komórkę.
-
-Oto osiem poleceń brainfucka:
-+ : inkrementuje (zwiększa o jeden) wartość aktualnie wskazywanej komórki
-- : dekrementuje (zmniejsza o jeden) wartość aktualnie wskazywanej komórki
-> : przesuwa wskaźnik na następną komórkę (w prawo)
-< : przesuwa wskaźnik na poprzednią komórkę (w lewo)
-. : wyświetla wartość bieżącej komórki (w formie znaku ASCII, np. 65 = 'A')
-, : wczytuje (jeden) znak z wejścia do bieżącej komórki
-    (konkretnie jego numer z tabeli ASCII)
-[ : jeśli wartość w bieżącej komórce jest rózna zero, przechodzi do
-    odpowiadającego ]; w przeciwnym wypdaku przechodzi do następnej instrukcji
-] : Jeśli wartość w bieżącej komórce jest rózna od zera, przechodzi do
-    następnej instrukcji; w przeciwnym wypdaku przechodzi do odpowiadającego [
-
-[ i ] oznaczają pętlę while. Oczywiście każda pętla rozpoczęta [
-musi być zakończona ].
-
-Zobaczmy kilka prostych programów w brainfucku.
-
-
-++++++ [ > ++++++++++ < - ] > +++++ .
-
-Ten program wypisuje literę 'A'. Najpierw zwiększa wartość komórki #1 do 6.
-Komórka #1 będzie wykorzystana w pętli. Następnie program wchodzi w pętlę ([)
-i przechodzi do komórki #2. Pętla wykonuje się sześć razy (komórka #1 jest
-dekrementowana sześć razy, nim osiągnie wartość zero, kiedy to program
-przechodzi do odpowiadającego ] i wykonuje kolejne instrukcje).
-
-W tym momencie wskaźnik pokazuje na komórkę #1, mającą wartość 0, podczas gdy
-komórka #2 ma wartość 60. Przesuwamy wskaźnik na komórkę #2, inkrementujemy ją
-pięć razy, uzyskując wartość 65. Następnie wyświetlamy wartość komórki #2.
-65 to 'A' w tabeli ASCII, więc właśnie ten znak jest wypisany na konsolę.
-
-
-, [ > + < - ] > .
-
-Ten program wczytuje znak z wejścia i umieszcza jego kod ASCII w komórce #1.
-Następnie zaczyna się pętla, w której znajdują się następujące instrukcje: 
-przesunięcie wskaźnika na komórkę #2, inkrementacja wartości komóri #2,
-powrót do komórki #1 i dekrementacja wartości komórki #1. Instrukcje pętli
-wykonują się aż wartość komórki #1 osiągnie zero, a komórka #2 osiągnie
-poprednią wartość komórki #1. Ponieważ na końcu pętli wskaźnik pokazuje na
-komórkę #1, po pętli następuje instrukcja przejścia do komórki #2 i wysłanie
-jej wartości (w formie znaku ASCII) na wyjście.
-
-Zauważ, że odstępy służą wyłącznie poprawie czytelności.
-Równie dobrze można powyższy program zapisać tak:
-
-,[>+<-]>.
-
-
-Spróbuj odgadnąć, co robi poniższy program:
-
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
-
-Ten program pobiera z wejścia dwie liczby i je mnoży.
-
-Po wczytaniu dwóch wejść (do komórek #1 i #2) następuje pętla zewnętrzna,
-warunkowana wartością komórki #1. Następnie program przechodzi do komórki #2
-i rozpoczyna pętlę wewnętrzną z warunkiem zakończenia w komórce #2,
-inkrementującą komórkę #3. Tu jednak pojawia się problem: w chwili zakończenia
-wewnętrznej pętli komórka #2 ma wartość zero. W takim razie wewętrzna pętla
-nie wywoła się następny raz. Aby rozwiązać ten problem, inkrementujemy także
-wartość komórki #4, a następnie kopiujemy jej wartość do komórki #2.
-Ostatecznie wynik działania znajduje się w komórce #3.
-```
-
-I to właśnie jest brainfuck. Nie taki trudny, co? W ramach rozrywki możesz
-napisać własne programy w brainfucku. Możesz też napisać interpreter brainfucka
-w innym języku. Implementacja interpretera to dość proste zadanie. Jeśli
-jesteś masochistą, spróbuj napisać interpreter brainfucka w... brainfucku.
diff --git a/pt-br/bf.html.markdown b/pt-br/bf.html.markdown
new file mode 100644
index 00000000..d6d7c6e9
--- /dev/null
+++ b/pt-br/bf.html.markdown
@@ -0,0 +1,85 @@
+---
+language: bf
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Suzane Sant Ana", "http://github.com/suuuzi"]
+    - ["Rodrigo Muniz", "http://github.com/muniz95"]
+lang: pt-br
+---
+
+Brainfuck (em letras minúsculas, exceto no início de frases) é uma linguagem de
+programação Turing-completa extremamente simples com apenas 8 comandos.
+
+```
+Qualquer caractere exceto "><+-.,[]" (sem contar as aspas) é ignorado.
+
+Brainfuck é representado por um vetor com 30 000 células inicializadas em zero
+e um ponteiro de dados que aponta para a célula atual.
+
+Existem 8 comandos:
++ : Incrementa o valor da célula atual em 1.
+- : Decrementa o valor da célula atual em 1.
+> : Move o ponteiro de dados para a célula seguinte (célula à direita).
+< : Move o ponteiro de dados para a célula anterior (célula à esquerda).
+. : Imprime o valor ASCII da célula atual. (ex. 65 = 'A').
+, : Lê um único caractere para a célula atual.
+[ : Se o valor da célula atual for zero, salta para o ] correspondente.
+    Caso contrário, passa para a instrução seguinte.
+] : Se o valor da célula atual for zero, passa para a instrução seguinte.
+    Caso contrário, volta para a instrução relativa ao [ correspondente.
+
+[ e ] formam um ciclo while. Obviamente, devem ser equilibrados.
+
+Vamos ver alguns exemplos básicos em brainfuck:
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Este programa imprime a letra 'A'. Primeiro incrementa a célula #1 para 6.
+A célula #1 será usada num ciclo. Depois é iniciado o ciclo ([) e move-se
+o ponteiro de dados para a célula #2. O valor da célula #2 é incrementado 10
+vezes, move-se o ponteiro de dados de volta para a célula #1, e decrementa-se
+a célula #1. Este ciclo acontece 6 vezes (são necessários 6 decrementos para
+a célula #1 chegar a 0, momento em que se salta para o ] correspondente,
+continuando com a instrução seguinte).
+
+Nesta altura estamos na célula #1, cujo valor é 0, enquanto a célula #2
+tem o valor 60. Movemos o ponteiro de dados para a célula #2, incrementa-se 5
+vezes para um valor final de 65, e então é impresso o valor da célula #2. O valor
+65 corresponde ao caractere 'A' em ASCII, então 'A' é impresso no terminal.
+
+, [ > + < - ] > .
+
+Este programa lê um caractere e copia o seu valor para a célula #1. Um ciclo é
+iniciado. Movemos o ponteiro de dados para a célula #2, incrementamos o valor na
+célula #2, movemos o ponteiro de dados de volta para a célula #1 e finalmente
+decrementamos o valor na célula #1. Isto continua até o valor na célula #1 ser
+igual a 0 e a célula #2 ter o antigo valor da célula #1. Como o ponteiro de
+dados está apontando para a célula #1 no fim do ciclo, movemos o ponteiro para a
+célula #2 e imprimimos o valor em ASCII.
+
+Os espaços servem apenas para tornar o programa mais legível. Podemos escrever
+o mesmo programa da seguinte maneira:
+
+,[>+<-]>.
+
+Tente descobrir o que este programa faz:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Este programa lê dois números e os multiplica.
+
+Basicamente o programa pede dois caracteres ao usuário. Depois é iniciado um
+ciclo exterior controlado pelo valor da célula #1. Movemos o ponteiro de dados
+para a célula #2 e inicia-se o ciclo interior controlado pelo valor da célula
+#2, incrementando o valor da célula #3. Porém existe um problema, no final do
+ciclo interior: a célula #2 tem o valor 0. Para resolver este problema o valor da
+célula #4 é também incrementado e copiado para a célula #2.
+```
+
+E isto é brainfuck. Simples, não? Por divertimento você pode escrever os
+seus próprios programas em brainfuck, ou então escrever um interpretador de
+brainfuck em outra linguagem. O interpretador é relativamente fácil de se
+implementar, mas caso você seja masoquista, tente escrever um interpretador de
+brainfuck… em brainfuck.
diff --git a/pt-br/brainfuck-pt.html.markdown b/pt-br/brainfuck-pt.html.markdown
deleted file mode 100644
index 9e4b458d..00000000
--- a/pt-br/brainfuck-pt.html.markdown
+++ /dev/null
@@ -1,85 +0,0 @@
----
-language: brainfuck
-contributors:
-    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-    - ["Mathias Bynens", "http://mathiasbynens.be/"]
-translators:
-    - ["Suzane Sant Ana", "http://github.com/suuuzi"]
-    - ["Rodrigo Muniz", "http://github.com/muniz95"]
-lang: pt-br
----
-
-Brainfuck (em letras minúsculas, exceto no início de frases) é uma linguagem de
-programação Turing-completa extremamente simples com apenas 8 comandos.
-
-```
-Qualquer caractere exceto "><+-.,[]" (sem contar as aspas) é ignorado.
-
-Brainfuck é representado por um vetor com 30 000 células inicializadas em zero
-e um ponteiro de dados que aponta para a célula atual.
-
-Existem 8 comandos:
-+ : Incrementa o valor da célula atual em 1.
-- : Decrementa o valor da célula atual em 1.
-> : Move o ponteiro de dados para a célula seguinte (célula à direita).
-< : Move o ponteiro de dados para a célula anterior (célula à esquerda).
-. : Imprime o valor ASCII da célula atual. (ex. 65 = 'A').
-, : Lê um único caractere para a célula atual.
-[ : Se o valor da célula atual for zero, salta para o ] correspondente.
-    Caso contrário, passa para a instrução seguinte.
-] : Se o valor da célula atual for zero, passa para a instrução seguinte.
-    Caso contrário, volta para a instrução relativa ao [ correspondente.
-
-[ e ] formam um ciclo while. Obviamente, devem ser equilibrados.
-
-Vamos ver alguns exemplos básicos em brainfuck:
-
-++++++ [ > ++++++++++ < - ] > +++++ .
-
-Este programa imprime a letra 'A'. Primeiro incrementa a célula #1 para 6.
-A célula #1 será usada num ciclo. Depois é iniciado o ciclo ([) e move-se
-o ponteiro de dados para a célula #2. O valor da célula #2 é incrementado 10
-vezes, move-se o ponteiro de dados de volta para a célula #1, e decrementa-se
-a célula #1. Este ciclo acontece 6 vezes (são necessários 6 decrementos para
-a célula #1 chegar a 0, momento em que se salta para o ] correspondente,
-continuando com a instrução seguinte).
-
-Nesta altura estamos na célula #1, cujo valor é 0, enquanto a célula #2
-tem o valor 60. Movemos o ponteiro de dados para a célula #2, incrementa-se 5
-vezes para um valor final de 65, e então é impresso o valor da célula #2. O valor
-65 corresponde ao caractere 'A' em ASCII, então 'A' é impresso no terminal.
-
-, [ > + < - ] > .
-
-Este programa lê um caractere e copia o seu valor para a célula #1. Um ciclo é
-iniciado. Movemos o ponteiro de dados para a célula #2, incrementamos o valor na
-célula #2, movemos o ponteiro de dados de volta para a célula #1 e finalmente
-decrementamos o valor na célula #1. Isto continua até o valor na célula #1 ser
-igual a 0 e a célula #2 ter o antigo valor da célula #1. Como o ponteiro de
-dados está apontando para a célula #1 no fim do ciclo, movemos o ponteiro para a
-célula #2 e imprimimos o valor em ASCII.
-
-Os espaços servem apenas para tornar o programa mais legível. Podemos escrever
-o mesmo programa da seguinte maneira:
-
-,[>+<-]>.
-
-Tente descobrir o que este programa faz:
-
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
-
-Este programa lê dois números e os multiplica.
-
-Basicamente o programa pede dois caracteres ao usuário. Depois é iniciado um
-ciclo exterior controlado pelo valor da célula #1. Movemos o ponteiro de dados
-para a célula #2 e inicia-se o ciclo interior controlado pelo valor da célula
-#2, incrementando o valor da célula #3. Porém existe um problema, no final do
-ciclo interior: a célula #2 tem o valor 0. Para resolver este problema o valor da
-célula #4 é também incrementado e copiado para a célula #2.
-```
-
-E isto é brainfuck. Simples, não? Por divertimento você pode escrever os
-seus próprios programas em brainfuck, ou então escrever um interpretador de
-brainfuck em outra linguagem. O interpretador é relativamente fácil de se
-implementar, mas caso você seja masoquista, tente escrever um interpretador de
-brainfuck… em brainfuck.
diff --git a/pt-pt/bf.html.markdown b/pt-pt/bf.html.markdown
new file mode 100644
index 00000000..da4c787f
--- /dev/null
+++ b/pt-pt/bf.html.markdown
@@ -0,0 +1,84 @@
+---
+language: brainfuck
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Joao Marques", "http://github.com/mrshankly"]
+lang: pt-pt
+---
+
+Brainfuck (não capitalizado excepto no início de uma frase) é uma linguagem de
+programação Turing-completa extremamente simples com apenas 8 comandos.
+
+```
+Qualquer caractere excepto "><+-.,[]" (não contar com as aspas) é ignorado.
+
+Brainfuck é representado por um vector com 30 000 células inicializadas a zero
+e um ponteiro de dados que aponta para a célula actual.
+
+Existem 8 comandos:
++ : Incrementa o valor da célula actual em 1.
+- : Decrementa o valor da célula actual em 1.
+> : Move o ponteiro de dados para a célula seguinte (célula à direita).
+< : Move o ponteiro de dados para a célula anterior (célula à esquerda).
+. : Imprime o valor ASCII da célula actual. (ex. 65 = 'A').
+, : Lê um único caractere para a célula actual.
+[ : Se o valor da célula actual for zero, salta para o ] correspondente.
+    Caso contrário, passa para a instrução seguinte.
+] : Se o valor da célula actual for zero, passa para a instrução seguinte.
+    Caso contrário, volta para a instrução relativa ao [ correspondente.
+
+[ e ] formam um ciclo while. Obviamente, devem ser equilibrados.
+
+Vejamos alguns programas básicos de brainfuck.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Este programa imprime a letra 'A'. Primeiro incrementa a célula #1 para 6.
+A célula #1 será usada num ciclo. Depois é iniciado o ciclo ([) e move-se
+o ponteiro de dados para a célula #2. Incrementa-se o valor da célula #2 10
+vezes, move-se o ponteiro de dados de volta para a célula #1, e decrementa-se
+a célula #1. Este ciclo acontece 6 vezes (são necessários 6 decrementos para
+a célula #1 chegar a 0, momento em que se salta para o ] correspondente,
+continuando com a instrução seguinte).
+
+Nesta altura encontramo-nos na célula #1, cujo valor é 0, enquanto a célula #2
+tem o valor 60. Movemos o ponteiro de dados para a célula #2, incrementa-se 5
+vezes para um valor final de 65, é então impresso o valor da célula #2. Ao valor
+65 corresponde o caractere 'A' em ASCII, 'A' é então impresso para o terminal.
+
+, [ > + < - ] > .
+
+Este programa lê um caractere e copia o seu valor para a célula #1. Um ciclo é
+iniciado. Movemos o ponteiro de dados para a célula #2, incrementamos o valor na
+célula #2, movemos o ponteiro de dados de volta para a célula #1, finalmente
+decrementamos o valor na célula #1. Isto continua até o valor na célula #1 ser
+igual a 0 e a célula #2 ter o antigo valor da célula #1. Como o ponteiro de
+dados está a apontar para a célula #1 no fim do ciclo, movemos o ponteiro para a
+célula #2 e imprimimos o valor em ASCII.
+
+Os espaços servem apenas para tornar o programa mais legível. Podemos escrever
+o mesmo programa da seguinte maneira:
+
+,[>+<-]>.
+
+Tenta descobrir o que este programa faz:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Este programa lê dois números e multiplica-os.
+
+Basicamente o programa pede dois caracteres ao utilizador. Depois é iniciado um
+ciclo exterior controlado pelo valor da célula #1. Movemos o ponteiro de dados
+para a célula #2 e inicia-se o ciclo interior controlado pelo valor da célula
+#2, incrementando o valor da célula #3. Contudo, existe um problema, no final do
+ciclo interior a célula #2 tem o valor 0. Para resolver este problema o valor da
+célula #4 é também incrementado e copiado para a célula #2.
+```
+
+Fica então explicado brainfuck. Simples, não? Por divertimento podes escrever os
+teus próprios programas em brainfuck, ou então escrever um interpretador de
+brainfuck noutra linguagem. O interpretador é relativamente fácil de se
+implementar, mas se fores masoquista, tenta escrever um interpretador de
+brainfuck… em brainfuck.
diff --git a/pt-pt/brainfuck-pt.html.markdown b/pt-pt/brainfuck-pt.html.markdown
deleted file mode 100644
index da4c787f..00000000
--- a/pt-pt/brainfuck-pt.html.markdown
+++ /dev/null
@@ -1,84 +0,0 @@
----
-language: brainfuck
-contributors:
-    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-    - ["Mathias Bynens", "http://mathiasbynens.be/"]
-translators:
-    - ["Joao Marques", "http://github.com/mrshankly"]
-lang: pt-pt
----
-
-Brainfuck (não capitalizado excepto no início de uma frase) é uma linguagem de
-programação Turing-completa extremamente simples com apenas 8 comandos.
-
-```
-Qualquer caractere excepto "><+-.,[]" (não contar com as aspas) é ignorado.
-
-Brainfuck é representado por um vector com 30 000 células inicializadas a zero
-e um ponteiro de dados que aponta para a célula actual.
-
-Existem 8 comandos:
-+ : Incrementa o valor da célula actual em 1.
-- : Decrementa o valor da célula actual em 1.
-> : Move o ponteiro de dados para a célula seguinte (célula à direita).
-< : Move o ponteiro de dados para a célula anterior (célula à esquerda).
-. : Imprime o valor ASCII da célula actual. (ex. 65 = 'A').
-, : Lê um único caractere para a célula actual.
-[ : Se o valor da célula actual for zero, salta para o ] correspondente.
-    Caso contrário, passa para a instrução seguinte.
-] : Se o valor da célula actual for zero, passa para a instrução seguinte.
-    Caso contrário, volta para a instrução relativa ao [ correspondente.
-
-[ e ] formam um ciclo while. Obviamente, devem ser equilibrados.
-
-Vejamos alguns programas básicos de brainfuck.
-
-++++++ [ > ++++++++++ < - ] > +++++ .
-
-Este programa imprime a letra 'A'. Primeiro incrementa a célula #1 para 6.
-A célula #1 será usada num ciclo. Depois é iniciado o ciclo ([) e move-se
-o ponteiro de dados para a célula #2. Incrementa-se o valor da célula #2 10
-vezes, move-se o ponteiro de dados de volta para a célula #1, e decrementa-se
-a célula #1. Este ciclo acontece 6 vezes (são necessários 6 decrementos para
-a célula #1 chegar a 0, momento em que se salta para o ] correspondente,
-continuando com a instrução seguinte).
-
-Nesta altura encontramo-nos na célula #1, cujo valor é 0, enquanto a célula #2
-tem o valor 60. Movemos o ponteiro de dados para a célula #2, incrementa-se 5
-vezes para um valor final de 65, é então impresso o valor da célula #2. Ao valor
-65 corresponde o caractere 'A' em ASCII, 'A' é então impresso para o terminal.
-
-, [ > + < - ] > .
-
-Este programa lê um caractere e copia o seu valor para a célula #1. Um ciclo é
-iniciado. Movemos o ponteiro de dados para a célula #2, incrementamos o valor na
-célula #2, movemos o ponteiro de dados de volta para a célula #1, finalmente
-decrementamos o valor na célula #1. Isto continua até o valor na célula #1 ser
-igual a 0 e a célula #2 ter o antigo valor da célula #1. Como o ponteiro de
-dados está a apontar para a célula #1 no fim do ciclo, movemos o ponteiro para a
-célula #2 e imprimimos o valor em ASCII.
-
-Os espaços servem apenas para tornar o programa mais legível. Podemos escrever
-o mesmo programa da seguinte maneira:
-
-,[>+<-]>.
-
-Tenta descobrir o que este programa faz:
-
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
-
-Este programa lê dois números e multiplica-os.
-
-Basicamente o programa pede dois caracteres ao utilizador. Depois é iniciado um
-ciclo exterior controlado pelo valor da célula #1. Movemos o ponteiro de dados
-para a célula #2 e inicia-se o ciclo interior controlado pelo valor da célula
-#2, incrementando o valor da célula #3. Contudo, existe um problema, no final do
-ciclo interior a célula #2 tem o valor 0. Para resolver este problema o valor da
-célula #4 é também incrementado e copiado para a célula #2.
-```
-
-Fica então explicado brainfuck. Simples, não? Por divertimento podes escrever os
-teus próprios programas em brainfuck, ou então escrever um interpretador de
-brainfuck noutra linguagem. O interpretador é relativamente fácil de se
-implementar, mas se fores masoquista, tenta escrever um interpretador de
-brainfuck… em brainfuck.
diff --git a/ru-ru/bf.html.markdown b/ru-ru/bf.html.markdown
new file mode 100644
index 00000000..20f0fa56
--- /dev/null
+++ b/ru-ru/bf.html.markdown
@@ -0,0 +1,85 @@
+---
+language: bf
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Dmitry Bessonov", "https://github.com/TheDmitry"]
+lang: ru-ru
+---
+
+Brainfuck (пишется маленькими буквами, кроме начала предложения) - это очень
+маленький Тьюринг-полный язык программирования лишь с 8 командами.
+
+Вы можете испытать brainfuck в вашем браузере с помощью [brainfuck-визуализатора](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+```
+Любой символ, кроме "><+-.,[]", игнорируется, за исключением кавычек.
+
+Brainfuck представлен массивом из 30000 ячеек, инициализированных нулями,
+и указателем с позицией в текущей ячейке.
+
+Всего восемь команд:
++ : Увеличивает значение на единицу в текущей ячейке.
+- : Уменьшает значение на единицу в текущей ячейке.
+> : Смещает указатель данных на следующую ячейку (ячейку справа).
+< : Смещает указатель данных на предыдущую ячейку (ячейку слева).
+. : Печатает ASCII символ из текущей ячейки (напр. 65 = 'A').
+, : Записывает один входной символ в текущую ячейку.
+[ : Если значение в текущей ячейке равно нулю, то пропустить все команды
+    до соответствующей ] . В противном случае, перейти к следующей инструкции.
+] : Если значение в текущей ячейке равно нулю, то перейти к следующей инструкции.
+    В противном случае, вернуться назад к соответствующей [ .
+
+[ и ] образуют цикл while. Естественно, они должны быть сбалансированы.
+
+Давайте рассмотрим некоторые базовые brainfuck-программы.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Эта программа выводит букву 'A'. Сначала программа увеличивает значение
+ячейки №1 до 6. Ячейка №1 будет использоваться циклом. Затем программа входит
+в цикл ([) и переходит к ячейке №2. Ячейка №2 увеличивается до 10, переходим
+назад к ячейке №1 и уменьшаем ячейку №1. Этот цикл проходит 6 раз (ячейка №1
+уменьшается до нуля, и с этого места пропускает инструкции до соответствующей ]
+и идет дальше).
+
+В этот момент мы находимся в ячейке №1, которая имеет значение 0, значение
+ячейки №2 пока 60. Мы переходим на ячейку №2, увеличиваем 5 раз, до значения 65,
+и затем выводим значение ячейки №2. Код 65 является символом 'A' в кодировке ASCII,
+так что 'A' выводится на терминал.
+
+
+, [ > + < - ] > .
+
+Данная программа считывает символ из пользовательского ввода и копирует символ
+в ячейку №1. Затем мы начинаем цикл. Переходим к ячейке №2, увеличиваем значение
+ячейки №2, идем назад к ячейке №1 и уменьшаем значение ячейки №1. Это продолжается
+до тех пор, пока ячейка №1 не равна 0, а ячейка №2 сохраняет старое значение
+ячейки №1. Мы завершаем цикл на ячейке №1, поэтому переходим в ячейку №2 и
+затем выводим символ ASCII.
+
+Также имейте в виду, что пробелы здесь исключительно для читабельности. Вы можете
+легко написать и так:
+
+,[>+<-]>.
+
+Попытайтесь разгадать, что следующая программа делает:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Программа принимает два числа на вход и умножает их.
+
+Суть в том, что программа сначала читает два ввода. Затем начинается внешний цикл,
+сохраняя ячейку №1. Затем программа перемещается в ячейку №2, и начинается
+внутренний цикл с сохранением ячейки №2, увеличивая ячейку №3. Однако появляется
+проблема: В конце внутреннего цикла ячейка №2 равна нулю. В этом случае,
+внутренний цикл не будет работать уже в следующий раз. Чтобы решить эту проблему,
+мы также увеличим ячейку №4, а затем копируем ячейку №4 в ячейку №2.
+Итак, ячейка №3 - результат.
+```
+
+Это и есть brainfuck. Не так уж сложно, правда? Забавы ради, вы можете написать
+свою собственную brainfuck-программу или интерпретатор на другом языке.
+Интерпретатор достаточно легко реализовать, но если вы мазохист, попробуйте
+написать brainfuck-интерпретатор... на языке brainfuck.
diff --git a/ru-ru/brainfuck-ru.html.markdown b/ru-ru/brainfuck-ru.html.markdown
deleted file mode 100644
index fcee185f..00000000
--- a/ru-ru/brainfuck-ru.html.markdown
+++ /dev/null
@@ -1,85 +0,0 @@
----
-language: brainfuck
-contributors:
-    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-    - ["Mathias Bynens", "http://mathiasbynens.be/"]
-translators:
-    - ["Dmitry Bessonov", "https://github.com/TheDmitry"]
-lang: ru-ru
----
-
-Brainfuck (пишется маленькими буквами, кроме начала предложения) - это очень
-маленький Тьюринг-полный язык программирования лишь с 8 командами.
-
-Вы можете испытать brainfuck в вашем браузере с помощью [brainfuck-визуализатора](http://fatiherikli.github.io/brainfuck-visualizer/).
-
-```
-Любой символ, кроме "><+-.,[]", игнорируется, за исключением кавычек.
-
-Brainfuck представлен массивом из 30000 ячеек, инициализированных нулями,
-и указателем с позицией в текущей ячейке.
-
-Всего восемь команд:
-+ : Увеличивает значение на единицу в текущей ячейке.
-- : Уменьшает значение на единицу в текущей ячейке.
-> : Смещает указатель данных на следующую ячейку (ячейку справа).
-< : Смещает указатель данных на предыдущую ячейку (ячейку слева).
-. : Печатает ASCII символ из текущей ячейки (напр. 65 = 'A').
-, : Записывает один входной символ в текущую ячейку.
-[ : Если значение в текущей ячейке равно нулю, то пропустить все команды
-    до соответствующей ] . В противном случае, перейти к следующей инструкции.
-] : Если значение в текущей ячейке равно нулю, то перейти к следующей инструкции.
-    В противном случае, вернуться назад к соответствующей [ .
-
-[ и ] образуют цикл while. Естественно, они должны быть сбалансированы.
-
-Давайте рассмотрим некоторые базовые brainfuck-программы.
-
-++++++ [ > ++++++++++ < - ] > +++++ .
-
-Эта программа выводит букву 'A'. Сначала программа увеличивает значение
-ячейки №1 до 6. Ячейка №1 будет использоваться циклом. Затем программа входит
-в цикл ([) и переходит к ячейке №2. Ячейка №2 увеличивается до 10, переходим
-назад к ячейке №1 и уменьшаем ячейку №1. Этот цикл проходит 6 раз (ячейка №1
-уменьшается до нуля, и с этого места пропускает инструкции до соответствующей ]
-и идет дальше).
-
-В этот момент мы находимся в ячейке №1, которая имеет значение 0, значение
-ячейки №2 пока 60. Мы переходим на ячейку №2, увеличиваем 5 раз, до значения 65,
-и затем выводим значение ячейки №2. Код 65 является символом 'A' в кодировке ASCII,
-так что 'A' выводится на терминал.
-
-
-, [ > + < - ] > .
-
-Данная программа считывает символ из пользовательского ввода и копирует символ
-в ячейку №1. Затем мы начинаем цикл. Переходим к ячейке №2, увеличиваем значение
-ячейки №2, идем назад к ячейке №1 и уменьшаем значение ячейки №1. Это продолжается
-до тех пор, пока ячейка №1 не равна 0, а ячейка №2 сохраняет старое значение
-ячейки №1. Мы завершаем цикл на ячейке №1, поэтому переходим в ячейку №2 и
-затем выводим символ ASCII.
-
-Также имейте в виду, что пробелы здесь исключительно для читабельности. Вы можете
-легко написать и так:
-
-,[>+<-]>.
-
-Попытайтесь разгадать, что следующая программа делает:
-
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
-
-Программа принимает два числа на вход и умножает их.
-
-Суть в том, что программа сначала читает два ввода. Затем начинается внешний цикл,
-сохраняя ячейку №1. Затем программа перемещается в ячейку №2, и начинается
-внутренний цикл с сохранением ячейки №2, увеличивая ячейку №3. Однако появляется
-проблема: В конце внутреннего цикла ячейка №2 равна нулю. В этом случае,
-внутренний цикл не будет работать уже в следующий раз. Чтобы решить эту проблему,
-мы также увеличим ячейку №4, а затем копируем ячейку №4 в ячейку №2.
-Итак, ячейка №3 - результат.
-```
-
-Это и есть brainfuck. Не так уж сложно, правда? Забавы ради, вы можете написать
-свою собственную brainfuck-программу или интерпретатор на другом языке.
-Интерпретатор достаточно легко реализовать, но если вы мазохист, попробуйте
-написать brainfuck-интерпретатор... на языке brainfuck.
diff --git a/tr-tr/bf-tr.html.markdown b/tr-tr/bf-tr.html.markdown
new file mode 100644
index 00000000..e7015cd0
--- /dev/null
+++ b/tr-tr/bf-tr.html.markdown
@@ -0,0 +1,87 @@
+---
+language: bf
+filename: brainfuck-tr
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io"]
+translators:
+    - ["Haydar KULEKCI", "http://scanf.info/"]
+lang: tr-tr
+---
+
+Brainfuck (normalde brainfuck olarak bütün harfleri küçük olarak yazılır.) 
+son derece minimal bir programlama dilidir. (Sadece 8 komut) ve tamamen 
+Turing'dir.
+
+```
+"><+-.,[]" (tırnak işaretleri hariç) karakterleri dışındaki her karakter
+gözardı edilir.
+
+Brainfuck 30,000 hücresi olan ve ilk değerleri sıfır olarak atanmış bir
+dizidir. İşaretçi ilk hücreyi işaret eder.
+
+Sekiz komut vardır:
++ : Geçerli hücrenin değerini bir artırır.
+- : Geçerli hücrenin değerini bir azaltır.
+> : Veri işaretçisini bir sonraki hücreye hareket ettirir(sağdaki hücreye).
+< : Veri işaretçisini bir önceki hücreye hareket ettirir(soldaki hücreye).
+. : Geçerli hücrenin ASCII değerini yazdırır (örn: 65 = 'A').
+, : Bir girdilik karakteri aktif hücre için okur.
+[ : Eğer geçerli hücredeki değer sıfır ise, ]ifadesine atlar.
+    Diğer durumlarda bir sonraki yönergeye geçer.
+] : Eğer geçerli hücredeki değer sıfır ise, bir sonraki yönergeye geçer.
+    Diğer durumlarda, [ ifadesine karşılık gelen yönergelere döner.
+
+[ ve ] bir while döngüsü oluşturur. Açıkça, dengeli olmalıdırlar.
+
+Basit bir brainfuck programına göz atalım.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Bu program 'A' karaterini ekrana basar. İlk olarak, #1'inci hücre 6'ya artırılır.
+#1'inci hücre döngü için kullanılacaktır. Sonra, ([) döngüsüne girilir ve
+#2'inci hücreye hareket edilir. #2'inci hücre 10 kez artırılır, #1'inci hücreye
+geri dönülür. #1 hücresini bir azaltır. Bu döngü 6 kez gerçekleşir. (Bu 6 kez
+azaltmak demektir, #1 hücresi 0 değerini alır ve bu noktada ] ifadesini atlar).
+
+Bu noktada, biz #1 hücresindeyiz, değeri şu anda 0 ve #2 hücresinin değeri
+60'tır. Biz #2 hücresine hareket diyoruz ve bu hücreyi 5 defa artırıyoruz.
+#2'nin şu anki değeri 65 olur. Sonra #2 hücresinin ASCII karşılığını
+yazdırıyoruz. 65 değerinin ASCII karşılığı 'A'dır. Ekrana 'A' yazılacaktır.
+
+
+, [ > + < - ] > .
+
+Bu program kullanıcıdan bir girdi okur, ve karakteri bir diğer hücreye yazdırır,
+ve daha sonra aynı karakteri ekrana yazdırır.
+
+, ifadesi kullanıcıdan karakteri #1 hücresine okur. Sonra bir döngü
+başlar. #2 hücresine hareket edilir, #2 hücresinin değeri bir artırılır, #1
+hücresine geri dönülür, ve #1 hücresinin değer bir azaltılır. Bu #1 hücresinin
+değeri 0 olana kadar devam eder ve #2 hücresi #1'in eski değerini tutar. Çünkü
+biz #1 hücresindeki verileri döngü süresince #2 hücresine taşıyoruz, ve sonunda
+#2 hücresinin ASCII değerini yazdırıyoruz.
+
+Boşluk karakteri sadece okunabilirliği artırmak içindir. Aşağıdaki gibi de
+yazabilirsiniz.
+
+,[>+<-]>.
+
+
+Bu uygulamanın ne yaptığına bakalım:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Bu program 2 sayı alır, ve birbiri ile çarpar.
+
+Özetle, ilk olarak iki girdi alır. Sonra, #1 hücresinde şarta bağlı harici bir
+döngü başlar. Sonra #2 ye hareket edilir, ve içerde #2 hücresine bağlı bir döngü
+daha başlar ve #3 hücresinin değerini artırır. Ama, Bir problem vardır: iç
+döngünün sonunda #2'inci hücrenin değeri 0 olacaktır. Bunu çözmek için #4
+hücresinin de değerini yükseltiyoruz, ve sonra #4 hücresinin değerini #2'ye
+kopyalıyoruz.
+```
+
+İşte brainfuck. Zor değil değil mi? Eğlenmek için kendi programınızı
+yazabilirsiniz, veya farklı bir dilde brainfuck yorumlayıcısı yazabilirsiniz.
+Yorumlayıcı oldukça basittir, ama mazoşist iseniz, brainfuck içerisinde bir
+brainfuck yorumlayıcısı yazmayı deneyebilirsiniz.
diff --git a/tr-tr/brainfuck-tr.html.markdown b/tr-tr/brainfuck-tr.html.markdown
deleted file mode 100644
index bd842b17..00000000
--- a/tr-tr/brainfuck-tr.html.markdown
+++ /dev/null
@@ -1,87 +0,0 @@
----
-language: brainfuck
-filename: brainfuck-tr
-contributors:
-    - ["Prajit Ramachandran", "http://prajitr.github.io"]
-translators:
-    - ["Haydar KULEKCI", "http://scanf.info/"]
-lang: tr-tr
----
-
-Brainfuck (normalde brainfuck olarak bütün harfleri küçük olarak yazılır.) 
-son derece minimal bir programlama dilidir. (Sadece 8 komut) ve tamamen 
-Turing'dir.
-
-```
-"><+-.,[]" (tırnak işaretleri hariç) karakterleri dışındaki her karakter
-gözardı edilir.
-
-Brainfuck 30,000 hücresi olan ve ilk değerleri sıfır olarak atanmış bir
-dizidir. İşaretçi ilk hücreyi işaret eder.
-
-Sekiz komut vardır:
-+ : Geçerli hücrenin değerini bir artırır.
-- : Geçerli hücrenin değerini bir azaltır.
-> : Veri işaretçisini bir sonraki hücreye hareket ettirir(sağdaki hücreye).
-< : Veri işaretçisini bir önceki hücreye hareket ettirir(soldaki hücreye).
-. : Geçerli hücrenin ASCII değerini yazdırır (örn: 65 = 'A').
-, : Bir girdilik karakteri aktif hücre için okur.
-[ : Eğer geçerli hücredeki değer sıfır ise, ]ifadesine atlar.
-    Diğer durumlarda bir sonraki yönergeye geçer.
-] : Eğer geçerli hücredeki değer sıfır ise, bir sonraki yönergeye geçer.
-    Diğer durumlarda, [ ifadesine karşılık gelen yönergelere döner.
-
-[ ve ] bir while döngüsü oluşturur. Açıkça, dengeli olmalıdırlar.
-
-Basit bir brainfuck programına göz atalım.
-
-++++++ [ > ++++++++++ < - ] > +++++ .
-
-Bu program 'A' karaterini ekrana basar. İlk olarak, #1'inci hücre 6'ya artırılır.
-#1'inci hücre döngü için kullanılacaktır. Sonra, ([) döngüsüne girilir ve
-#2'inci hücreye hareket edilir. #2'inci hücre 10 kez artırılır, #1'inci hücreye
-geri dönülür. #1 hücresini bir azaltır. Bu döngü 6 kez gerçekleşir. (Bu 6 kez
-azaltmak demektir, #1 hücresi 0 değerini alır ve bu noktada ] ifadesini atlar).
-
-Bu noktada, biz #1 hücresindeyiz, değeri şu anda 0 ve #2 hücresinin değeri
-60'tır. Biz #2 hücresine hareket diyoruz ve bu hücreyi 5 defa artırıyoruz.
-#2'nin şu anki değeri 65 olur. Sonra #2 hücresinin ASCII karşılığını
-yazdırıyoruz. 65 değerinin ASCII karşılığı 'A'dır. Ekrana 'A' yazılacaktır.
-
-
-, [ > + < - ] > .
-
-Bu program kullanıcıdan bir girdi okur, ve karakteri bir diğer hücreye yazdırır,
-ve daha sonra aynı karakteri ekrana yazdırır.
-
-, ifadesi kullanıcıdan karakteri #1 hücresine okur. Sonra bir döngü
-başlar. #2 hücresine hareket edilir, #2 hücresinin değeri bir artırılır, #1
-hücresine geri dönülür, ve #1 hücresinin değer bir azaltılır. Bu #1 hücresinin
-değeri 0 olana kadar devam eder ve #2 hücresi #1'in eski değerini tutar. Çünkü
-biz #1 hücresindeki verileri döngü süresince #2 hücresine taşıyoruz, ve sonunda
-#2 hücresinin ASCII değerini yazdırıyoruz.
-
-Boşluk karakteri sadece okunabilirliği artırmak içindir. Aşağıdaki gibi de
-yazabilirsiniz.
-
-,[>+<-]>.
-
-
-Bu uygulamanın ne yaptığına bakalım:
-
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
-
-Bu program 2 sayı alır, ve birbiri ile çarpar.
-
-Özetle, ilk olarak iki girdi alır. Sonra, #1 hücresinde şarta bağlı harici bir
-döngü başlar. Sonra #2 ye hareket edilir, ve içerde #2 hücresine bağlı bir döngü
-daha başlar ve #3 hücresinin değerini artırır. Ama, Bir problem vardır: iç
-döngünün sonunda #2'inci hücrenin değeri 0 olacaktır. Bunu çözmek için #4
-hücresinin de değerini yükseltiyoruz, ve sonra #4 hücresinin değerini #2'ye
-kopyalıyoruz.
-```
-
-İşte brainfuck. Zor değil değil mi? Eğlenmek için kendi programınızı
-yazabilirsiniz, veya farklı bir dilde brainfuck yorumlayıcısı yazabilirsiniz.
-Yorumlayıcı oldukça basittir, ama mazoşist iseniz, brainfuck içerisinde bir
-brainfuck yorumlayıcısı yazmayı deneyebilirsiniz.
diff --git a/zh-cn/bf-cn.html.markdown b/zh-cn/bf-cn.html.markdown
new file mode 100644
index 00000000..6cea3012
--- /dev/null
+++ b/zh-cn/bf-cn.html.markdown
@@ -0,0 +1,70 @@
+---
+language: bf
+lang: zh-cn
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["lyuehh", "https://github.com/lyuehh"]
+---
+
+Brainfuck 是一个极小的只有8个指令的图灵完全的编程语言。
+
+```
+除"><+-.,[]"之外的的任何字符都会被忽略 (不包含双引号)。
+
+Brainfuck 包含一个有30,000个单元为0的数组，和
+一个数据指针指向当前的单元。
+
+8个指令如下:
++ : 指针指向的单元的值加1
+- : 指针指向的单元的值减1
+> : 将指针移动到下一个单元(右边的元素)
+< : 将指针移动到上一个单元(左边的元素)
+. : 打印当前单元的内容的ASCII值 (比如 65 = 'A').
+, : 读取一个字符到当前的单元
+[ : 如果当前单元的值是0，则向后调转到对应的]处
+] : 如果当前单元的值不是0，则向前跳转到对应的[处
+
+[ 和 ] 组成了一个while循环。很明显，它们必须配对。
+
+让我们看一些基本的brainfuck 程序。
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+这个程序打印字母'A'。首先，它把 #1 增加到6，使用它来作为循环条件，
+然后，进入循环，将指针移动到 #2 ，将 #2 的值增加到10，然后
+移动回 #1，将单元 #1 的值减1，然后继续。循环共进行了6次。
+
+这时，我们在 #1，它的值为0，#2 的值为60，我们移动到
+#2，将 #2 的内容加上5，然后将 #2 的内容打印出来，65在
+ASCII中表示'A', 所以'A'就会被打印出来。
+
+
+, [ > + < - ] > .
+
+这个程序从用户的输入中读取一个字符，然后把它复制到 #1。
+然后我们开始一个循环，移动到 #2，将 #2 的值加1，再移动回 #1，将 #1
+的值减1，直到 #1的值为0，这样 #2 里就保存了 #1 的旧值，循环结束时我们
+在 #1，这时我们移动到 #2，然后把字符以ASCII打印出来。
+
+而且要记住的一点就是，空格在这里只是为了可读性，你可以将他们写成这样:
+
+,[>+<-]>.
+
+试着思考一下这段程序是干什么的:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+这段程序从输入接收2个参数，然后将他们相乘。
+
+先读取2个输入，然后开始外层循环，以 #1 作为终止条件，然后将指针移动到
+#2，然后开始 #2 的内层循环，将 #3 加1。但是这里有一个小问题，在内层
+循环结束的时候，#2 的值是0了，那么下次执行外层循环的时候，就有问题了。
+为了解决这个问题，我们可以增加 #4 的值，然后把 #4 的值复制到 #2，
+最后结果就保存在 #3 中了。
+```
+好了这就是brainfuck了。也没那么难，是吧？为了好玩，你可以写你自己的
+brainfuck程序，或者用其他语言写一个brainfuck的解释器，解释器非常容易
+实现，但是如果你是一个自虐狂的话，你可以尝试用brainfuck写一个brainfuk的
+解释器。
diff --git a/zh-cn/brainfuck-cn.html.markdown b/zh-cn/brainfuck-cn.html.markdown
deleted file mode 100644
index a6f3fa09..00000000
--- a/zh-cn/brainfuck-cn.html.markdown
+++ /dev/null
@@ -1,70 +0,0 @@
----
-language: brainfuck
-lang: zh-cn
-contributors:
-    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-    - ["Mathias Bynens", "http://mathiasbynens.be/"]
-translators:
-    - ["lyuehh", "https://github.com/lyuehh"]
----
-
-Brainfuck 是一个极小的只有8个指令的图灵完全的编程语言。
-
-```
-除"><+-.,[]"之外的的任何字符都会被忽略 (不包含双引号)。
-
-Brainfuck 包含一个有30,000个单元为0的数组，和
-一个数据指针指向当前的单元。
-
-8个指令如下:
-+ : 指针指向的单元的值加1
-- : 指针指向的单元的值减1
-> : 将指针移动到下一个单元(右边的元素)
-< : 将指针移动到上一个单元(左边的元素)
-. : 打印当前单元的内容的ASCII值 (比如 65 = 'A').
-, : 读取一个字符到当前的单元
-[ : 如果当前单元的值是0，则向后调转到对应的]处
-] : 如果当前单元的值不是0，则向前跳转到对应的[处
-
-[ 和 ] 组成了一个while循环。很明显，它们必须配对。
-
-让我们看一些基本的brainfuck 程序。
-
-++++++ [ > ++++++++++ < - ] > +++++ .
-
-这个程序打印字母'A'。首先，它把 #1 增加到6，使用它来作为循环条件，
-然后，进入循环，将指针移动到 #2 ，将 #2 的值增加到10，然后
-移动回 #1，将单元 #1 的值减1，然后继续。循环共进行了6次。
-
-这时，我们在 #1，它的值为0，#2 的值为60，我们移动到
-#2，将 #2 的内容加上5，然后将 #2 的内容打印出来，65在
-ASCII中表示'A', 所以'A'就会被打印出来。
-
-
-, [ > + < - ] > .
-
-这个程序从用户的输入中读取一个字符，然后把它复制到 #1。
-然后我们开始一个循环，移动到 #2，将 #2 的值加1，再移动回 #1，将 #1
-的值减1，直到 #1的值为0，这样 #2 里就保存了 #1 的旧值，循环结束时我们
-在 #1，这时我们移动到 #2，然后把字符以ASCII打印出来。
-
-而且要记住的一点就是，空格在这里只是为了可读性，你可以将他们写成这样:
-
-,[>+<-]>.
-
-试着思考一下这段程序是干什么的:
-
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
-
-这段程序从输入接收2个参数，然后将他们相乘。
-
-先读取2个输入，然后开始外层循环，以 #1 作为终止条件，然后将指针移动到
-#2，然后开始 #2 的内层循环，将 #3 加1。但是这里有一个小问题，在内层
-循环结束的时候，#2 的值是0了，那么下次执行外层循环的时候，就有问题了。
-为了解决这个问题，我们可以增加 #4 的值，然后把 #4 的值复制到 #2，
-最后结果就保存在 #3 中了。
-```
-好了这就是brainfuck了。也没那么难，是吧？为了好玩，你可以写你自己的
-brainfuck程序，或者用其他语言写一个brainfuck的解释器，解释器非常容易
-实现，但是如果你是一个自虐狂的话，你可以尝试用brainfuck写一个brainfuk的
-解释器。
-- 
cgit v1.2.3