diff --git a/2019/clacks/italian/description.json b/2019/clacks/italian/description.json
index 5a742ddc0..e5052cbb7 100644
--- a/2019/clacks/italian/description.json
+++ b/2019/clacks/italian/description.json
@@ -2,27 +2,27 @@
  {
   "input": "Solution: https://youtu.be/jsYwFizhncE",
   "translatedText": "Soluzione: https://youtu.be/jsYwFizhncE",
-  "n_reviews": 0
+  "n_reviews": 1
  },
  {
   "input": "Even prettier solution: https://youtu.be/brU5yLm9DZM",
   "translatedText": "Soluzione ancora più carina: https://youtu.be/brU5yLm9DZM",
-  "n_reviews": 0
+  "n_reviews": 1
  },
  {
   "input": "Help fund future projects: https://www.patreon.com/3blue1brown",
   "translatedText": "Aiuta a finanziare progetti futuri: https://www.patreon.com/3blue1brown",
-  "n_reviews": 0
+  "n_reviews": 1
  },
  {
   "input": "An equally valuable form of support is to simply share some of the videos.",
   "translatedText": "Una forma di supporto altrettanto preziosa è semplicemente condividere alcuni video.",
-  "n_reviews": 0
+  "n_reviews": 1
  },
  {
   "input": "Special thanks to these supporters: http://3b1b.co/clacks-thanks",
   "translatedText": "Un ringraziamento speciale a questi sostenitori: http://3b1b.co/clacks-thanks",
-  "n_reviews": 0
+  "n_reviews": 1
  },
  {
   "input": "",
@@ -31,8 +31,8 @@
  },
  {
   "input": "New to this channel?  It's all about teaching math visually.  Take a look and see if there's anything you'd like to learn.",
-  "translatedText": "Nuovo su questo canale? Si tratta di insegnare la matematica visivamente. Dai un'occhiata e vedi se c'è qualcosa che vorresti imparare.",
-  "n_reviews": 0
+  "translatedText": "Nuovo su questo canale? Si tratta di insegnare la matematica in modo visuale. Dai un'occhiata e vedi se c'è qualcosa che vorresti imparare.",
+  "n_reviews": 1
  },
  {
   "input": "",
@@ -42,12 +42,12 @@
  {
   "input": "NY Times blog post about this problem:",
   "translatedText": "Post del blog del NY Times su questo problema:",
-  "n_reviews": 0
+  "n_reviews": 1
  },
  {
   "input": "https://wordplay.blogs.nytimes.com/2014/03/10/pi/",
   "translatedText": "https://wordplay.blogs.nytimes.com/2014/03/10/pi/",
-  "n_reviews": 0
+  "n_reviews": 1
  },
  {
   "input": "",
@@ -57,12 +57,12 @@
  {
   "input": "The original paper by Gregory Galperin:",
   "translatedText": "L'articolo originale di Gregory Galperin:",
-  "n_reviews": 0
+  "n_reviews": 1
  },
  {
   "input": "https://www.maths.tcd.ie/~lebed/Galperin.%20Playing%20pool%20with%20pi.pdf",
   "translatedText": "https://www.maths.tcd.ie/~lebed/Galperin.%20Playing%20pool%20with%20pi.pdf",
-  "n_reviews": 0
+  "n_reviews": 1
  },
  {
   "input": "",
@@ -72,17 +72,17 @@
  {
   "input": "Evidently, Numberphile also described this problem (I had not known):",
   "translatedText": "Evidentemente Numberphile ha descritto anche questo problema (non lo sapevo):",
-  "n_reviews": 0
+  "n_reviews": 1
  },
  {
   "input": "https://youtu.be/abv4Fz7oNr0",
   "translatedText": "https://youtu.be/abv4Fz7oNr0",
-  "n_reviews": 0
+  "n_reviews": 1
  },
  {
   "input": "You'll notice that video has an added factor of 16 throughout, which is not here.  That's because they're only counting the collisions between blocks (well, balls in their case), and they're only counting to the point where the big block starts moving the other way.",
-  "translatedText": "Noterai che il video ha un fattore aggiuntivo di 16 in tutto, che non è qui. Questo perché contano solo le collisioni tra i blocchi (beh, le palle nel loro caso) e contano solo fino al punto in cui il grande blocco inizia a muoversi nella direzione opposta.",
-  "n_reviews": 0
+  "translatedText": "Noterai che il video ha un fattore aggiunto di 16 in tutto, che qui non c'è. Questo perché stanno contando solo le collisioni tra i blocchi (beh, palle nel loro caso), e stanno contando solo fino al punto in cui il grande blocco inizia a muoversi nell'altra direzione.",
+  "n_reviews": 1
  },
  {
   "input": "",
@@ -94,4 +94,4 @@
   "translatedText": "",
   "n_reviews": 0
  }
-]
\ No newline at end of file
+]
diff --git a/2019/clacks/italian/sentence_translations.json b/2019/clacks/italian/sentence_translations.json
index 9f1778781..969272438 100644
--- a/2019/clacks/italian/sentence_translations.json
+++ b/2019/clacks/italian/sentence_translations.json
@@ -1,19 +1,19 @@
 [
  {
   "input": "Sometimes, math and physics conspire in ways that just feel too good to be true.",
-  "translatedText": "A volte, la matematica e la fisica cospirano in modi che sembrano troppo belli per essere veri.",
+  "translatedText": "A volte, matematica e fisica complottano in modi che sembrano troppo belli per essere veri.",
   "model": "DeepL",
   "from_community_srt": "Alcune volte matematica e fisica si accordano in modi troppo belli per esser veri.",
-  "n_reviews": 0,
-  "start": 4.0,
-  "end": 8.0
+  "n_reviews": 1,
+  "start": 4,
+  "end": 8
  },
  {
   "input": "Let's play a strange sort of mathematical croquet.",
   "translatedText": "Giochiamo a uno strano tipo di croquet matematico.",
   "model": "DeepL",
   "from_community_srt": "Facciamo insieme un piccolo gioco matematico.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 8.64,
   "end": 10.78
  },
@@ -22,16 +22,16 @@
   "translatedText": "Avremo due blocchi scorrevoli e un muro.",
   "model": "DeepL",
   "from_community_srt": "Consideriamo due blocchi che si muovono e un muro.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 11.28,
   "end": 13.54
  },
  {
   "input": "The first block starts by coming in at some velocity from the right, while the second one starts out stationary.",
-  "translatedText": "Il primo blocco inizia ad arrivare con una certa velocità da destra, mentre il secondo parte da fermo.",
+  "translatedText": "Il primo blocco si muove ad una certa velocità arrivando da destra, mentre il secondo parte da fermo.",
   "model": "DeepL",
   "from_community_srt": "Il primo blocco si muove ad una certa velocità arrivando da destra, mentre il secondo parte da fermo.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 14.08,
   "end": 19.18
  },
@@ -40,69 +40,69 @@
   "translatedText": "Da fisici troppo idealisti, supponiamo che non ci sia attrito e che tutte le collisioni siano perfettamente elastiche, il che significa che non si perde energia.",
   "model": "DeepL",
   "from_community_srt": "Essendo una situazione fisica completamente idealizzata, assumiamo che non ci sia frizione e che tutte le collisioni siano perfettamente elastiche, cioè non c'è perdita di energia nel sistema.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 19.92,
   "end": 27.78
  },
  {
   "input": "The astute among you might complain that such collisions would make no sound, but your goal here is to count how many collisions take place, so in slight conflict with that assumption I want to leave a little clack sound to better draw your attention to that count.",
-  "translatedText": "I più smaliziati potrebbero lamentarsi del fatto che tali collisioni non producono alcun suono, ma il tuo obiettivo qui è quello di contare quante collisioni avvengono, quindi in leggero contrasto con questa ipotesi voglio lasciare un piccolo suono di clack per attirare meglio la tua attenzione sul conteggio.",
+  "translatedText": "Gli attenti potrebbero lamentarsi che tali collisioni non farebbero suono, ma l'obiettivo è contare quante collisioni avvengono, quindi in leggero contrasto con quell'assunzione lascio un piccolo suono di clack per attirare meglio l'attenzione sul conteggio.",
   "model": "DeepL",
   "from_community_srt": "I più astuti tra di voi potranno dire che tali collisioni non produrrebbero alcun suono, ma il nostro obiettivo sarà quello di contare il numero di collisioni, dunque il leggero conflitto con le nostre assunzioni iniziali, lascerò il suono delle collisioni solo per enfatizzarle e agevolarne il conteggio.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 28.4,
   "end": 41.68
  },
  {
   "input": "The simplest case is when both blocks have the same mass.",
-  "translatedText": "Il caso più semplice è quando entrambi i blocchi hanno la stessa massa.",
+  "translatedText": "Il caso più semplice: entrambi i blocchi hanno la stessa massa.",
   "model": "DeepL",
   "from_community_srt": "Il caso più semplice è quando entrambi i blocchi hanno la stessa massa.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 42.32,
   "end": 44.92
  },
  {
   "input": "The first block hits the second, transferring all of its momentum, then the second one bounces off the wall, and then transfers all of its momentum back to the first, which then sails off towards infinity.",
-  "translatedText": "Il primo blocco colpisce il secondo, trasferendo tutto il suo slancio, poi il secondo rimbalza sul muro e trasferisce di nuovo tutto il suo slancio al primo, che poi vola verso l'infinito.",
+  "translatedText": "Il primo blocco colpisce il secondo, trasferendo tutto il suo momento, poi il secondo rimbalza sul muro e quindi trasferisce tutto il suo momento al primo, che poi si dirige verso l'infinito.",
   "model": "DeepL",
   "from_community_srt": "Il primo blocco colpisce il secondo, trasferendo tutta la propria quantità di moto. Poi il secondo blocco rimbalza sul muro e trasferisce ancora tutta la propria quantità di moto al primo, che procede infine a destra,",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 45.38,
   "end": 55.28
  },
  {
   "input": "Three total clacks.",
-  "translatedText": "Tre colpi in totale.",
+  "translatedText": "Tre collisioni in totale.",
   "model": "DeepL",
   "from_community_srt": "verso infinito. 3 collisioni in totale.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 55.86,
   "end": 56.8
  },
  {
   "input": "What about if the first block was 100 times the mass of the second one?",
-  "translatedText": "E se il primo blocco fosse 100 volte la massa del secondo?",
+  "translatedText": "E se il primo blocco avesse 100 volte la massa del secondo?",
   "model": "DeepL",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 57.44,
   "end": 61.18
  },
  {
   "input": "I promise I will explain to you all the relevant physics in due course, it's not entirely obvious how you would predict the dynamics here, but in the spirit of getting to the punchline, let's watch what happens.",
-  "translatedText": "Ti prometto che a tempo debito ti spiegherò tutta la fisica pertinente, non è del tutto ovvio come si possa prevedere la dinamica in questo caso, ma nello spirito di arrivare alla battuta finale, guardiamo cosa succede.",
+  "translatedText": "Prometto che spiegherò tutta la fisica rilevante a suo tempo, non è del tutto ovvio come prevedere la dinamica qui, ma nello spirito di arrivare alla battuta finale, vediamo cosa succede.",
   "model": "DeepL",
   "from_community_srt": "Cosa succede se il primo blocco ha 100 volte la massa del secondo? Prometto di spiegare tutti tutte le interazioni fisiche nel processo, non è interamente ovvio come predire la dinamica del sistema, ma nello spirito di arrivare al risultato vediamo cosa succede.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 61.84,
   "end": 71.28
  },
  {
   "input": "The second one will keep bouncing back and forth between the wall and the first block, 100 times its mass, like a satisfying game of Breakout, slowly and discreetly redirecting that first block's momentum to point in the opposite direction.",
-  "translatedText": "Il secondo continuerà a rimbalzare avanti e indietro tra il muro e il primo blocco, 100 volte la sua massa, come in una soddisfacente partita a Breakout, reindirizzando lentamente e discretamente lo slancio del primo blocco nella direzione opposta.",
+  "translatedText": "Il secondo continuerà a rimbalzare tra il muro e il primo blocco, che ha 100 volte la sua massa, come in un gioco di Breakout, ridirezionando lentamente il momento del primo blocco in direzione opposta.",
   "model": "DeepL",
   "from_community_srt": "Il secondo blocco continuerà a rimbalzare tra il muro e il primo blocco che ha 100 volte la sua massa, come una partita di Breakout, e lentamente porta la quantità di moto del primo blocco a puntare in direzione opposta.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 71.9,
   "end": 83.84
  },
@@ -111,16 +111,16 @@
   "translatedText": "In totale, ci saranno 31 collisioni prima che ogni blocco scivoli via verso l'infinito, per non essere mai più toccato.",
   "model": "DeepL",
   "from_community_srt": "In totale, ci saranno 31 collisioni prima che ogni blocco andrà verso infinito, senza mai più toccarsi tra di loro.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 83.84,
   "end": 90.62
  },
  {
   "input": "What if the first block was 10,000 times the mass of the second one?",
-  "translatedText": "E se il primo blocco fosse 10.000 volte la massa del secondo?",
+  "translatedText": "E se il primo blocco avesse 10.000 volte la massa del secondo?",
   "model": "DeepL",
   "from_community_srt": "Cosa succede invece se il primo blocco è 10000 volte più massivo del secondo? In quel caso,",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 91.58,
   "end": 95.18
  },
@@ -129,7 +129,7 @@
   "translatedText": "In questo caso, si verificherebbe un numero maggiore di collisioni, tutte molto rapide, che porterebbero a un totale di 313 collisioni.",
   "model": "DeepL",
   "from_community_srt": "ci saranno molte più collisioni, che accadranno molto rapidamente in un momento, e in totale saranno 313.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 95.86,
   "end": 108.16
  },
@@ -138,24 +138,24 @@
   "translatedText": "Beh, in realtà, aspetta.",
   "model": "DeepL",
   "from_community_srt": "Aspetta...",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 108.92,
   "end": 110.04
  },
  {
   "input": "Wait for it.",
-  "translatedText": "Aspetta.",
+  "translatedText": "",
   "model": "DeepL",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 110.66,
   "end": 110.04
  },
  {
   "input": "Wait for it.",
-  "translatedText": "Aspetta.",
+  "translatedText": "Aspetta, aspetta...",
   "model": "DeepL",
   "from_community_srt": "adesso arriva...",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 110.66,
   "end": 114.28
  },
@@ -164,16 +164,16 @@
   "translatedText": "Ok, 314 clic.",
   "model": "DeepL",
   "from_community_srt": "adesso arriva... okay 314 collisioni.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 116.98,
   "end": 118.48
  },
  {
   "input": "If the first block was 1,000,000 times the mass of the other, then again, with all of our crazy idealistic conditions, almost all of the clacks happen in one big burst, this time resulting in a total of 3,141 collisions.",
-  "translatedText": "Se il primo blocco fosse 1.000.000 di volte la massa dell'altro, anche in questo caso, con tutte le nostre folli condizioni idealistiche, quasi tutte le collisioni avverrebbero in un'unica grande esplosione, questa volta per un totale di 3.141 collisioni.",
+  "translatedText": "Se il primo blocco avesse 1.000.000 volte la massa dell'altro, anche in questo caso, con tutte le nostre folli condizioni idealistiche, quasi tutte le collisioni avverrebbero in un'unica grande esplosione, questa volta per un totale di 3.141 collisioni.",
   "model": "DeepL",
   "from_community_srt": "Se avesse invece 1000000 di volte la massa del secondo allora ancora, con tutte le nostre condizioni ideali, quasi tutte le collisioni avvengono in un intervallo di tempo molto piccolo, e questa volta saranno 3141 in totale.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 119.3,
   "end": 132.68
  },
@@ -182,7 +182,7 @@
   "translatedText": "Forse vedi lo schema, anche se è perdonabile se non lo vedi, dato che sfida ogni aspettativa.",
   "model": "DeepL",
   "from_community_srt": "Forse sarai riuscito a scorgere già lo schema, e anche se non lo riconosci è perdonabile in quanto è totalmente inaspettato.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 133.76,
   "end": 138.6
  },
@@ -191,16 +191,16 @@
   "translatedText": "Quando la massa del primo blocco è una potenza di 100 volte la massa del secondo, il numero totale di collisioni ha le stesse cifre di pi greco.",
   "model": "DeepL",
   "from_community_srt": "Quando la massa del primo blocco e una potenza di 100 volte la massa del secondo, il numero di collisioni avrà le stesse cifre di quelle iniziali del pi greco.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 138.6,
   "end": 147.2
  },
  {
   "input": "This absolutely blew my mind when it was first shared with me.",
-  "translatedText": "Questa notizia mi ha assolutamente sconvolto quando è stata condivisa per la prima volta.",
+  "translatedText": "Questo mi ha assolutamente stupito la prima volta che lo vidi.",
   "model": "DeepL",
   "from_community_srt": "Tutto questo mi ha completamente sconvolto quando mi è stato spiegato per la prima volta.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 148.24,
   "end": 151.26
  },
@@ -209,25 +209,25 @@
   "translatedText": "Merito dello spettatore Henry Cavill per avermi fatto conoscere questo fatto, scoperto originariamente dal matematico Gregory Galperin nel 1995 e pubblicato nel 2003.",
   "model": "DeepL",
   "from_community_srt": "Ringrazio Henry Kavle per avermi introdotto a questo risultato, scoperto in origine dal matematico Gregory Galperin nel 1995 e pubblicato nel 2003.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 151.66,
   "end": 160.96
  },
  {
   "input": "Part of what I love about this is that if ever there were Olympic games for algorithms that compute pi, this one would have to win medals both for being the most elegant, and for being the most comically inefficient.",
-  "translatedText": "Se mai ci fossero delle Olimpiadi per gli algoritmi che calcolano il pi greco, questo dovrebbe vincere le medaglie sia per essere il più elegante, sia per essere il più comicamente inefficiente.",
+  "translatedText": "Una cosa che amo di questo è che se ci fossero Giochi Olimpici per algoritmi che calcolano pi greco, questo vincerebbe medaglie per essere sia il più elegante sia il più comicamente inefficiente.",
   "model": "DeepL",
   "from_community_srt": "Penso che se ci fossero dei giochi olimpici per algoritmi che approssimano pi greco, questo vincerebbe sicuramente una due medaglie: quella per l'algoritmo più elegante, e quella per il più comicamente inefficiente.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 161.92,
   "end": 173.36
  },
  {
   "input": "I mean, think about the actual algorithm here.",
-  "translatedText": "Pensa all'algoritmo vero e proprio.",
+  "translatedText": "Voglio dire, pensa all'algoritmo vero e proprio.",
   "model": "DeepL",
   "from_community_srt": "Voglio dire, pensiamo all'algoritmo: Step 1:",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 174.06,
   "end": 176.22
  },
@@ -236,7 +236,7 @@
   "translatedText": "Passo 1: implementare un motore fisico.",
   "model": "DeepL",
   "from_community_srt": "implementare un motore fisico.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 176.52,
   "end": 178.42
  },
@@ -245,16 +245,16 @@
   "translatedText": "Passo 2: scegli il numero di cifre d di pi greco che vuoi calcolare.",
   "model": "DeepL",
   "from_community_srt": "Step 2: scegliere il numero di cifre, d, di pi greco da calcolare.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 178.88,
-  "end": 183.0
+  "end": 183
  },
  {
   "input": "Step 3, set the mass of one of the blocks to be 100 to the power d-1, then send it travelling on a frictionless surface towards a block of mass 1.",
   "translatedText": "Passo 3: imposta la massa di uno dei blocchi a 100 alla potenza d-1, quindi fallo viaggiare su una superficie priva di attrito verso un blocco di massa 1.",
   "model": "DeepL",
   "from_community_srt": "Step 3: fissare la massa di un blocco a 100^{d -1} e lasciarlo scivolare su una superficie prima d'attrito verso un blocco di massa 1.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 183.68,
   "end": 192.28
  },
@@ -263,16 +263,16 @@
   "translatedText": "Passo 4: conta tutte le collisioni.",
   "model": "DeepL",
   "from_community_srt": "Step 4: contare il numero di collisioni.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 192.82,
   "end": 194.98
  },
  {
   "input": "For example, to calculate only 20 digits of pi, which fits so cleanly on this screen, one block would have to have 100 billion billion billion billion times the mass of the other, which if that small block was 1 kilogram, means the big one has a mass about 10 times that of the supermassive black hole at the center of the Milky Way.",
-  "translatedText": "Ad esempio, per calcolare solo 20 cifre di pi greco, che si adattano perfettamente a questo schermo, un blocco dovrebbe avere 100 miliardi di miliardi di miliardi di miliardi di miliardi di volte la massa dell'altro, il che, se il blocco piccolo è di 1 chilogrammo, significa che quello grande ha una massa circa 10 volte quella del buco nero supermassiccio al centro della Via Lattea.",
+  "translatedText": "Ad esempio, per calcolare solo 20 cifre di pi greco, un blocco dovrebbe avere una massa di 100 miliardi di miliardi di miliardi di miliardi di volte quella dell'altro, il che significa che se quel piccolo blocco fosse di 1 chilogrammo, il grande avrebbe una massa circa 10 volte quella del buco nero supermassiccio al centro della Via Lattea.",
   "model": "DeepL",
   "from_community_srt": "Quindi, per esempio, per calcolare solo 20 cifre del pi greco, che stanno bene all'interno di questo schermo un blocco dovrebbe avere 100 miliardi di miliardi di miliardi di miliardi di volte la massa dell'altro, cioè se il blocco piccolo avesse massa 1 kg, il blocco grande avrebbe massa 10 volte quella del buco nero supermassivo al centro della Via Lattea.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 196.42,
   "end": 214.98
  },
@@ -281,7 +281,7 @@
   "translatedText": "Ciò significa che dovresti contare 31 miliardi di miliardi di collisioni.",
   "model": "DeepL",
   "from_community_srt": "Ciò significa contare circa 31 miliardi di miliardi di collisioni e la frequenza di tali collisioni",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 215.64,
   "end": 218.92
  },
@@ -290,43 +290,43 @@
   "translatedText": "A un certo punto di questo processo virtuale, la frequenza dei clack sarebbe di circa 100 miliardi di miliardi di miliardi di clack al secondo.",
   "model": "DeepL",
   "from_community_srt": "in tale processo virtuale sarebbe di circa 100 miliardi di miliardi di miliardi di miliardi di collisioni al secondo.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 218.92,
   "end": 225.9
  },
  {
   "input": "So let's just say you would need very good numerical precision to get this working accurately, and it would take a very long time for the algorithm to complete.",
-  "translatedText": "Quindi, diciamo che per ottenere un funzionamento accurato è necessaria un'ottima precisione numerica e che l'algoritmo impiegherebbe molto tempo per essere completato.",
+  "translatedText": "Diciamo che avresti bisogno di precisione numerica molto elevata e ci vorrebbe molto tempo per completare l'algoritmo.",
   "model": "DeepL",
   "from_community_srt": "Ci sarebbe dunque bisogno di una straordinaria precisione numerica perché tutto questo funzionasse in maniera accurata,",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 226.38,
   "end": 233.48
  },
  {
   "input": "I'll emphasize again that this process is way over-idealized, quickly departing from anything that could possibly happen in real physics.",
-  "translatedText": "Sottolineo ancora una volta che questo processo è eccessivamente idealizzato e si discosta rapidamente da qualsiasi cosa possa accadere nella fisica reale.",
+  "translatedText": "Sottolineo ancora che questo processo è eccessivamente idealizzato, allontanandosi rapidamente da quanto possa accadere nella fisica reale.",
   "model": "DeepL",
   "from_community_srt": "e il processo impiegherebbe un tempo molto lungo per concludersi! Sottolineo ancora come tutto questo sia completamente idealizzato, e facilmente è qualcosa bel lontano da qualcosa che possa accadere in un setting fisico reale.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 234.3,
   "end": 240.96
  },
  {
   "input": "But of course, you all know this is not interesting because of its potential as an actual pi computing algorithm or as a pragmatic physics demonstration.",
-  "translatedText": "Ma ovviamente sapete tutti che questo non è interessante per il suo potenziale come algoritmo di calcolo o come dimostrazione di fisica pragmatica.",
+  "translatedText": "Ma ovviamente, sapete che questo non è interessante come algoritmo per calcolare pi greco o come dimostrazione pratica di fisica.",
   "model": "DeepL",
   "from_community_srt": "Ma chiaramente, questo è interessante non come potenziale algoritmo per calcolare le cifre del pi greco, o come una dimostrazione pratica di fisica.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 241.76,
   "end": 248.7
  },
  {
   "input": "It's mind-boggling because why on earth would pi show up here?",
-  "translatedText": "È sconcertante perché perché mai Pi dovrebbe presentarsi qui?",
+  "translatedText": "È sconcertante perché mai pi dovrebbe presentarsi qui?",
   "model": "DeepL",
   "from_community_srt": "È sorprendente invece constatare che le cifre di pi greco entrano in gioco! Ed è ancor più strano che sia proprio il pi greco a comparire:",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 249.12,
   "end": 254.44
  },
@@ -334,7 +334,7 @@
   "input": "And it's in such a weird way too.",
   "translatedText": "Ed è anche in un modo così strano.",
   "model": "DeepL",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 254.92,
   "end": 257.38
  },
@@ -343,7 +343,7 @@
   "translatedText": "Le sue cifre decimali contano qualcosa, ma di solito il pi greco compare quando il suo valore preciso descrive qualcosa di continuo.",
   "model": "DeepL",
   "from_community_srt": "le sue cifre servono a contare un qualcosa, mentre di solito, il suo valore preciso descrive invece un comportamento intrinsecamente continuo.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 257.46,
   "end": 263.94
  },
@@ -352,16 +352,16 @@
   "translatedText": "Ti mostrerò perché questo è vero.",
   "model": "DeepL",
   "from_community_srt": "Ti mostrerò perché tutto questo sia vero.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 264.8,
   "end": 266.2
  },
  {
   "input": "Where there is pi, there is a hidden circle, and in this case, that hidden circle comes from the conservation of energy.",
-  "translatedText": "Dove c'è il pi greco, c'è un cerchio nascosto e in questo caso il cerchio nascosto deriva dalla conservazione dell'energia.",
+  "translatedText": "Dove c'è pi greco, c'è un cerchio nascosto, e in questo caso, deriva dalla conservazione dell'energia.",
   "model": "DeepL",
   "from_community_srt": "Dove compare pi greco, c'è nascosto una circonferenza, e in questo caso tale circonferenza nascosta viene dalla conservazione dell'energia.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 266.58,
   "end": 271.62
  },
@@ -370,16 +370,16 @@
   "translatedText": "In realtà, vedrai due metodi distinti, ognuno dei quali è sorprendente quanto il fatto stesso.",
   "model": "DeepL",
   "from_community_srt": "In effetti vedremo due metodi separati che sono sorprendenti e entusiasmanti di per sé.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 272.06,
   "end": 277.38
  },
  {
   "input": "Delaying gratification though, I will make you wait until the next video to see what's going on.",
-  "translatedText": "Per ritardare la gratificazione, però, ti farò aspettare il prossimo video per vedere cosa succede.",
+  "translatedText": "Ritardando la gratificazione, vi farò aspettare il prossimo video per scoprire cosa succede.",
   "model": "DeepL",
   "from_community_srt": "Ma posticiperò questa gratificazione fino al prossimo video, nel quale ti mostrerò cosa realmente accade.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 278.16,
   "end": 282.24
  },
@@ -388,26 +388,26 @@
   "translatedText": "Nel frattempo, ti invito caldamente a provarci anche tu e a essere socievole.",
   "model": "DeepL",
   "from_community_srt": "Nel frattempo, puoi provare da solo ad attaccare questo problema. E non dimenticare di postare i tuoi risultati.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 282.52,
   "end": 287.64
  },
  {
   "input": "It's a hard puzzle, so it never hurts to recruit some other smart minds to the task.",
-  "translatedText": "È un rompicapo difficile, quindi non fa mai male reclutare altre menti intelligenti per questo compito.",
+  "translatedText": "È un rompicapo difficile, quindi non fa mai male coinvolgere altre menti intelligenti.",
   "model": "DeepL",
   "from_community_srt": "È un problema difficile, quindi non fa mai male coinvolgere altre menti per affrontarlo insieme.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 287.72,
   "end": 291.64
  },
  {
   "input": "Thanks for watching. I'll see you next time. Bye.",
-  "translatedText": "Grazie.",
+  "translatedText": "",
   "model": "DeepL",
   "from_community_srt": "È un problema difficile, quindi non fa mai male coinvolgere altre menti per affrontarlo insieme.",
-  "n_reviews": 0,
+  "n_reviews": 1,
   "start": 301.62,
   "end": 312.24
  }
-]
\ No newline at end of file
+]
diff --git a/2019/clacks/italian/title.json b/2019/clacks/italian/title.json
index b9df0b798..6251d55e2 100644
--- a/2019/clacks/italian/title.json
+++ b/2019/clacks/italian/title.json
@@ -2,4 +2,4 @@
  "input": "The most unexpected answer to a counting puzzle",
  "translatedText": "La risposta più inaspettata a un puzzle di conteggio",
  "n_reviews": 0
-}
\ No newline at end of file
+}
diff --git a/2020/hamming-codes-2/arabic/sentence_translations.json b/2020/hamming-codes-2/arabic/sentence_translations.json
index 98c49f4a4..a27b0398c 100644
--- a/2020/hamming-codes-2/arabic/sentence_translations.json
+++ b/2020/hamming-codes-2/arabic/sentence_translations.json
@@ -1,6 +1,6 @@
 [
  {
-  "input": "I'm assuming that everybody here is coming from part 1. ",
+  "input": "I'm assuming that everybody here is coming from part 1.",
   "translatedText": "أفترض أن الجميع هنا قادمون من الجزء الأول. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it. ",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "كنا نتحدث عن رموز هامينج، وهي طريقة لإنشاء كتلة من البيانات حيث تحمل معظم البتات رسالة ذات معنى، بينما يعمل عدد قليل آخر كنوع من التكرار، بطريقة بحيث إذا تم قلب أي جزء، إما رسالة بت أو بت متكرر، أي شيء في هذه الكتلة، سيكون جهاز الاستقبال قادرًا على تحديد وجود خطأ، وكيفية إصلاحه. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error. ",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "كانت الفكرة الأساسية المقدمة هناك هي كيفية استخدام عمليات التحقق من التكافؤ المتعددة للبحث الثنائي في طريقك إلى الخطأ. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -24,7 +24,7 @@
   "end": 27.16
  },
  {
-  "input": "In that video the goal was to make Hamming codes feel as hands-on and rediscoverable as possible. ",
+  "input": "In that video the goal was to make Hamming codes feel as hands-on and rediscoverable as possible.",
   "translatedText": "كان الهدف في هذا الفيديو هو جعل رموز هامينج تبدو عملية وقابلة لإعادة الاكتشاف قدر الإمكان. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -32,7 +32,7 @@
   "end": 34.6
  },
  {
-  "input": "hat there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error. In that video, the goal was to make Hamming codes feel as hands-on and rediscoverable as possible. But as ",
+  "input": "But as you start to think about actually implementing this, either in software or hardware, that framing may actually undersell how elegant these codes really are.",
   "translatedText": "ولكن عندما تبدأ في التفكير في تنفيذ هذا فعليًا، سواء في البرامج أو الأجهزة، فإن هذا الإطار قد يقلل في الواقع من مدى أناقة هذه الرموز حقًا. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -40,7 +40,7 @@
   "end": 43.46
  },
  {
-  "input": "You might think that you need to write an algorithm that keeps track of all the possible error locations and cuts that group in half with each check, but it's actually way, way simpler than that. ",
+  "input": "You might think that you need to write an algorithm that keeps track of all the possible error locations and cuts that group in half with each check, but it's actually way, way simpler than that.",
   "translatedText": "قد تظن أنك بحاجة إلى كتابة خوارزمية تتتبع جميع مواقع الأخطاء المحتملة وتقطع تلك المجموعة إلى النصف مع كل عملية تحقق، ولكنها في الواقع أبسط من ذلك بكثير. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -48,7 +48,7 @@
   "end": 53.48
  },
  {
-  "input": "If you read out the answers to the four parity checks we did in the last video, all as 1s and 0s instead of yeses and nos, it literally spells out the position of the error in binary. ",
+  "input": "If you read out the answers to the four parity checks we did in the last video, all as 1s and 0s instead of yeses and nos, it literally spells out the position of the error in binary.",
   "translatedText": "إذا قرأت الإجابات على عمليات التحقق من التكافؤ الأربعة التي قمنا بها في الفيديو الأخير، كلها كـ 1 و0 بدلاً من نعم ولا، فإنها توضح حرفيًا موضع الخطأ في النظام الثنائي. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "you read out the answers to the four parity checks we did in the last video, all as ones and zeros instead of yeses and nos, it literally spells out ",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "على سبيل المثال، الرقم 7 في النظام الثنائي يبدو مثل 0111، مما يعني أنه 4 زائد 2 زائد 1. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last. ",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "ولاحظ أين يقع الموضع 7، فهو يؤثر بالفعل على المجموعة الأولى من مجموعات التكافؤ، والثانية، والثالثة، ولكن ليس الأخيرة. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day. The goal here is to give you a very thorough understanding of one of the earlie ",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "لذا فإن قراءة نتائج عمليات التحقق الأربعة هذه من الأسفل إلى الأعلى توضح بالفعل موضع الخطأ. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -80,7 +80,7 @@
   "end": 87.54
  },
  {
-  "input": "st examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity groups, and the second, and the third, but not the last. So reading the results of those four checks ",
+  "input": "There's nothing special about the example 7, this works in general, and this makes the logic for implementing the whole scheme in hardware shockingly simple.",
   "translatedText": "لا يوجد شيء خاص في المثال 7، وهذا يعمل بشكل عام، وهذا يجعل منطق تنفيذ المخطط بأكمله في الأجهزة بسيطًا بشكل صادم. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -88,7 +88,7 @@
   "end": 95.82
  },
  {
-  "input": "Now if you want to see why this magic happens, take these 16 index labels for our positions, but instead of writing them in base 10, let's write them all in binary, running from 0000 up to 1111. ",
+  "input": "Now if you want to see why this magic happens, take these 16 index labels for our positions, but instead of writing them in base 10, let's write them all in binary, running from 0000 up to 1111.",
   "translatedText": "الآن إذا كنت تريد معرفة سبب حدوث هذا السحر، فخذ تسميات الفهرس الستة عشر هذه لمواقعنا، ولكن بدلاً من كتابتها في الأساس 10، دعنا نكتبها جميعًا بالنظام الثنائي، بدءًا من 0000 حتى 1111. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent. ",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "عندما نعيد هذه التصنيفات الثنائية إلى صناديقها، اسمحوا لي أن أؤكد أنها مختلفة عن البيانات التي يتم إرسالها بالفعل. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from. ",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "إنها ليست أكثر من مجرد تسمية مفاهيمية لمساعدتي ومساعدتك في فهم من أين أتت مجموعات التكافؤ الأربع. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary. ",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "ربما يتم تقويض أناقة الحصول على كل ما نتطلع إليه موصوفًا في النظام الثنائي بسبب الارتباك المتمثل في وجود كل ما نتطلع إليه موصوفًا في النظام الثنائي. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -120,7 +120,7 @@
   "end": 132.36
  },
  {
-  "input": "0, let's write them all in binary, running from 0000 up to 1111. ask feels at the star ",
+  "input": "It's worth it, though.",
   "translatedText": "إنه يستحق ذلك، على الرغم من ذلك. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -128,7 +128,7 @@
   "end": 134.12
  },
  {
-  "input": "Focus your attention just on that last bit of all of these labels, and then highlight the positions where that final bit is a 1. ",
+  "input": "Focus your attention just on that last bit of all of these labels, and then highlight the positions where that final bit is a 1.",
   "translatedText": "ركز انتباهك فقط على الجزء الأخير من كل هذه التسميات، ثم قم بتسليط الضوء على المواضع التي يكون فيها الجزء الأخير هو 1. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1? ",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "ما حصلنا عليه هو المجموعة الأولى من مجموعات التكافؤ الأربع لدينا، مما يعني أنه يمكنك تفسير هذا التحقق الأول على أنه يسأل، إذا كان هناك خطأ، فهل البت الأخير في موضع هذا الخطأ هو 1؟ ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -144,7 +144,7 @@
   "end": 155.74
  },
  {
-  "input": "Similarly, if you focus on the second to last bit, and highlight all the positions where that's a 1, you get the second parity group from our scheme. ",
+  "input": "Similarly, if you focus on the second to last bit, and highlight all the positions where that's a 1, you get the second parity group from our scheme.",
   "translatedText": "وبالمثل، إذا ركزت على الجزء الثاني قبل الأخير، وقمت بتمييز جميع المواضع التي يكون فيها الرقم 1، فستحصل على مجموعة التكافؤ الثانية من مخططنا. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -152,7 +152,7 @@
   "end": 166.16
  },
  {
-  "input": "ly spelled words. Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. ",
+  "input": "In other words, that second check is asking, hey, me again, if there's an error, is the second to last bit of that position a 1?",
   "translatedText": "بمعنى آخر، هذا الفحص الثاني يسألني مرة أخرى، إذا كان هناك خطأ، فهل الجزء الثاني قبل الأخير من هذا الموضع هو 1؟ ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "And so on. ",
+  "input": "And so on.",
   "translatedText": "وما إلى ذلك وهلم جرا. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -168,7 +168,7 @@
   "end": 176.9
  },
  {
-  "input": "The third parity check covers every position whose third to last bit is turned on, and the last one covers the last eight positions, those ones whose highest order bit is a 1. ",
+  "input": "The third parity check covers every position whose third to last bit is turned on, and the last one covers the last eight positions, those ones whose highest order bit is a 1.",
   "translatedText": "يغطي فحص التكافؤ الثالث كل موضع تم تشغيل البت من الثالث إلى الأخير، ويغطي الأخير المواضع الثمانية الأخيرة، تلك التي يكون أعلى بت لها هو 1. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -176,7 +176,7 @@
   "end": 188.74
  },
  {
-  "input": "everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary. ",
+  "input": "Everything we did earlier is the same as answering these four questions, which in turn is the same as spelling out a position in binary.",
   "translatedText": "كل ما فعلناه سابقًا هو نفس الإجابة على هذه الأسئلة الأربعة، والتي بدورها هي نفس توضيح الموضع في النظام الثنائي. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -184,7 +184,7 @@
   "end": 197.74
  },
  {
-  "input": "It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where tha ",
+  "input": "I hope this makes two things clearer.",
   "translatedText": "آمل أن يجعل هذا شيئين أكثر وضوحا. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "t final bit is a 1. What we get is the first of our four parity groups, which means that you can interpret that first check as asking, hey, if there's an err ",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "الأول هو كيفية التعميم بشكل منهجي على أحجام الكتل التي تكون أكبر من قوى اثنين. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -200,7 +200,7 @@
   "end": 206.46
  },
  {
-  "input": "If it takes more bits to describe each position, like six bits to describe 64 spots, then each of those bits gives you one of the parity groups that we need to check. ",
+  "input": "If it takes more bits to describe each position, like six bits to describe 64 spots, then each of those bits gives you one of the parity groups that we need to check.",
   "translatedText": "إذا كان الأمر يتطلب المزيد من البتات لوصف كل موضع، مثل ستة بتات لوصف 64 نقطة، فإن كل واحدة من هذه البتات تمنحك إحدى مجموعات التكافؤ التي نحتاج إلى التحقق منها. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -208,7 +208,7 @@
   "end": 216.68
  },
  {
-  "input": "maybe at the end or something like that, but as you'll see, having them sit in positions which are powers of 2 allows for something that's really elegant by the end. ",
+  "input": "Those of you who watched the chessboard puzzle I did with Matt Parker might find all this exceedingly familiar.",
   "translatedText": "أولئك منكم الذين شاهدوا لغز رقعة الشطرنج الذي قمت به مع مات باركر قد يجدون كل هذا مألوفًا للغاية. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -216,7 +216,7 @@
   "end": 223.18
  },
  {
-  "input": "It's the same core logic, but solving a different problem, and applied to a 64-squared chessboard. ",
+  "input": "It's the same core logic, but solving a different problem, and applied to a 64-squared chessboard.",
   "translatedText": "إنه نفس المنطق الأساسي، لكنه يحل مشكلة مختلفة، ويتم تطبيقه على رقعة شطرنج مكونة من 64 مربعًا. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -224,7 +224,7 @@
   "end": 228.78
  },
  {
-  "input": "The second thing I hope this makes clear is why our parity bits are sitting in the positions that are powers of two, for example 1, 2, 4, and 8. ",
+  "input": "The second thing I hope this makes clear is why our parity bits are sitting in the positions that are powers of two, for example 1, 2, 4, and 8.",
   "translatedText": "الأمر الثاني الذي آمل أن يوضحه هذا هو سبب وجود بتات التكافؤ لدينا في مواضع تمثل قوى العدد اثنين، على سبيل المثال 1 و2 و4 و8. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -232,7 +232,7 @@
   "end": 237.32
  },
  {
-  "input": "at goes on at position 0, but don't worry about that for now. The third parity check covers every position whose third to last bit is turned ",
+  "input": "These are the positions whose binary representation has just a single bit turned on.",
   "translatedText": "هذه هي المواضع التي تم تشغيل تمثيلها الثنائي بمقدار بت واحد فقط. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups. ",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "ما يعنيه ذلك هو أن كل واحدة من بتات التكافؤ هذه تقع داخل مجموعة واحدة فقط من مجموعات التكافؤ الأربع. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -248,7 +248,7 @@
   "end": 249.46
  },
  {
-  "input": "You can also see this in larger examples, where no matter how big you get, each parity bit conveniently touches only one of the groups. ",
+  "input": "You can also see this in larger examples, where no matter how big you get, each parity bit conveniently touches only one of the groups.",
   "translatedText": "يمكنك أيضًا رؤية ذلك في أمثلة أكبر، حيث بغض النظر عن حجمها، فإن كل بتة تكافؤ تلامس بسهولة مجموعة واحدة فقط من المجموعات. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -256,7 +256,7 @@
   "end": 259.34
  },
  {
-  "input": "Once you understand that these parity checks that we've focused so much of our time on are nothing more than a clever way to spell out the position of an error in binary, then we can draw a connection with a different way to think about hamming codes, one that is arguably a lot simpler and more elegant, and which can basically be written down with a single line of code. ",
+  "input": "Once you understand that these parity checks that we've focused so much of our time on are nothing more than a clever way to spell out the position of an error in binary, then we can draw a connection with a different way to think about hamming codes, one that is arguably a lot simpler and more elegant, and which can basically be written down with a single line of code.",
   "translatedText": "بمجرد أن تفهم أن عمليات التحقق من التكافؤ هذه التي ركزنا عليها كثيرًا من وقتنا ليست أكثر من طريقة ذكية لتوضيح موضع الخطأ في النظام الثنائي، فيمكننا بعد ذلك رسم اتصال بطريقة مختلفة للتفكير في الهام الرموز، التي يمكن القول إنها أبسط بكثير وأكثر أناقة، والتي يمكن كتابتها أساسًا باستخدام سطر واحد من التعليمات البرمجية. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -264,7 +264,7 @@
   "end": 283.24
  },
  {
-  "input": "It's based on the XOR function. ",
+  "input": "It's based on the XOR function.",
   "translatedText": "يعتمد على وظيفة XOR. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -272,7 +272,7 @@
   "end": 285.5
  },
  {
-  "input": "f 1s in the message is an even number. So for example right now, that total number of 1s is If it takes more bits to describe each p ",
+  "input": "XOR, for those of you who don't know, stands for exclusive or.",
   "translatedText": "XOR، لأولئك منكم الذين لا يعرفون، يرمز إلى حصري أو. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "osition, like six bits to describe 64 spots, then each of those bits gives you one of the parity groups that we need to check. that special bit to be a 1, making the count even. But if the block had already started off with a ",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "عندما تأخذ XOR لبتين، فسوف يُرجع 1 إذا تم تشغيل أي من تلك البتات، ولكن ليس إذا تم تشغيل كليهما أو إيقاف تشغيلهما. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "Phrased differently, it's the parity of these two bits. ",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "بصياغة مختلفة، إنه التكافؤ بين هاتين القطعتين. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -296,7 +296,7 @@
   "end": 302.98
  },
  {
-  "input": "it would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core ",
+  "input": "As a math person, I prefer to think about it as addition mod 2.",
   "translatedText": "باعتباري متخصصًا في الرياضيات، أفضّل التفكير في الأمر على أنه تعديل الإضافة 2. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -304,7 +304,7 @@
   "end": 306.76
  },
  {
-  "input": "logic, but solving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity bits are sitti ",
+  "input": "We also commonly talk about the XOR of two different bit strings, which basically does this component by component.",
   "translatedText": "نتحدث أيضًا بشكل شائع عن XOR لسلسلتين مختلفتين من البتات، والتي تقوم بشكل أساسي بتنفيذ هذا المكون تلو الآخر. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "It's like addition, but where you never carry. ",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "إنها مثل الإضافة، ولكن حيث لا تحملها أبدًا. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -320,7 +320,7 @@
   "end": 315.72
  },
  {
-  "input": "Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. ",
+  "input": "Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2.",
   "translatedText": "مرة أخرى، قد يفضل الأشخاص الأكثر ميلاً للرياضيات التفكير في هذا على أنه إضافة متجهين وتقليل التعديل 2. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -328,7 +328,7 @@
   "end": 322.48
  },
  {
-  "input": "of two, for example 1, 2, 4, and 8. These are the positions whose binary representation has just a single bit turned on. d say the parity is 0 or 1, which is typically more helpful once you start doing math with the idea. And this special bit that the sender uses to con ",
+  "input": "If you open up some Python right now and apply the caret operation between two integers, this is what it's doing but to the bit representations of those numbers under the hood.",
   "translatedText": "إذا قمت بفتح بعض لغة Python الآن وقمت بتطبيق عملية علامة الإقحام بين عددين صحيحين، فهذا ما تفعله ولكن على تمثيلات البت لتلك الأرقام الموجودة أسفل الغطاء. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "trol the parity is called the parity bit. And actually, we should be clear, if the receiver sees an odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure tha ",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "النقطة الأساسية بالنسبة لي ولكم هي أن أخذ XOR للعديد من سلاسل البت المختلفة هو وسيلة فعالة لحساب المحاكاة الساخرة لمجموعة من المجموعات المنفصلة، كما هو الحال مع الأعمدة، كل ذلك في ضربة واحدة. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation. ",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "وهذا يمنحنا طريقة رائعة إلى حد ما للتفكير في عمليات التحقق من التكافؤ المتعددة من خوارزمية كود هامينج الخاصة بنا حيث يتم تجميعها جميعًا معًا في عملية واحدة. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -352,7 +352,7 @@
   "end": 358.78
  },
  {
-  "input": "Though at first glance it does look very different. ",
+  "input": "Though at first glance it does look very different.",
   "translatedText": "على الرغم من أنها تبدو للوهلة الأولى مختلفة تمامًا. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -360,7 +360,7 @@
   "end": 362.18
  },
  {
-  "input": "Specifically write down the 16 positions in binary, like we had before, and now highlight the positions where the message bit is turned on to a 1, and then collect these positions into one big column and take the XOR. ",
+  "input": "Specifically write down the 16 positions in binary, like we had before, and now highlight the positions where the message bit is turned on to a 1, and then collect these positions into one big column and take the XOR.",
   "translatedText": "اكتب على وجه التحديد المواضع الستة عشر في النظام الثنائي، كما فعلنا من قبل، وقم الآن بتمييز المواضع التي تم فيها تشغيل بت الرسالة إلى 1، ثم قم بتجميع هذه المواضع في عمود واحد كبير وأخذ XOR. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -368,7 +368,7 @@
   "end": 377.1
  },
  {
-  "input": "You can probably guess that the 4 bits sitting at the bottom as a result are the same as the 4 parity checks we've come to know and love, but take a moment to actually think about why exactly. ",
+  "input": "You can probably guess that the 4 bits sitting at the bottom as a result are the same as the 4 parity checks we've come to know and love, but take a moment to actually think about why exactly.",
   "translatedText": "ربما يمكنك تخمين أن البتات الأربعة الموجودة في الأسفل نتيجة لذلك هي نفس عمليات التحقق من التكافؤ الأربعة التي عرفناها ونحبها، ولكن خذ لحظة للتفكير في السبب بالضبط. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -376,7 +376,7 @@
   "end": 389.2
  },
  {
-  "input": "This last column, for example, is counting all of the positions whose last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. ",
+  "input": "This last column, for example, is counting all of the positions whose last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group.",
   "translatedText": "هذا العمود الأخير، على سبيل المثال، يقوم بإحصاء جميع المواضع التي يكون الجزء الأخير منها هو 1، ولكننا يقتصرون بالفعل على المواضع المميزة فقط، لذا فهو يحسب بشكل فعال عدد المواضع المميزة التي جاءت من مجموعة التكافؤ الأولى. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is ",
+  "input": "Does that make sense?",
   "translatedText": "هل هذا منطقي؟ ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "turned on, but not if both are turned on or if both are turned off. Phrased differently, it's the parity of these two bits. full message down to a single bit, what they give us is a powerful building block for more sophisticated schemes. ",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "وبالمثل، يقوم العمود التالي بحساب عدد المواضع الموجودة في مجموعة التكافؤ الثانية، والمواضع التي يكون البت الثاني قبل الأخير هو 1، والتي يتم تمييزها أيضًا، وما إلى ذلك. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -400,7 +400,7 @@
   "end": 420.0
  },
  {
-  "input": "It's really just a small shift in perspective on the same thing we've been doing. ",
+  "input": "It's really just a small shift in perspective on the same thing we've been doing.",
   "translatedText": "إنه في الحقيقة مجرد تحول بسيط في المنظور حول نفس الشيء الذي كنا نفعله. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -408,7 +408,7 @@
   "end": 423.96
  },
  {
-  "input": "e also commonly talk about the XOR of two different bit s ",
+  "input": "And so you know where it goes from here.",
   "translatedText": "وهكذا تعرف إلى أين يتجه الأمر من هنا. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -416,7 +416,7 @@
   "end": 429.6
  },
  {
-  "input": "The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000. ",
+  "input": "The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
   "translatedText": "يكون المرسل مسؤولاً عن تبديل بعض بتات التكافؤ الخاصة للتأكد من أن المبلغ يصل إلى 0000. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error. ",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "الآن، بمجرد أن يصبح الأمر بهذا الشكل، فهذا يمنحنا طريقة رائعة للتفكير في السبب وراء توضيح هذه البتات الأربعة الناتجة في الأسفل موضع الخطأ بشكل مباشر. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "Let's say some bit in this block gets toggled from a 0 to a 1. ",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "لنفترض أنه تم تبديل جزء ما في هذه الكتلة من 0 إلى 1. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. ",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "ما يعنيه ذلك هو أن موضع هذا البت سيتم الآن تضمينه في إجمالي XOR، مما يغير المجموع من 0 إلى هذه القيمة المضمنة حديثًا بدلاً من ذلك، وهو موضع الخطأ. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -448,7 +448,7 @@
   "end": 463.82
  },
  {
-  "input": "Slightly less obviously, the same is true if there's an error that changes a 1 to a 0. ",
+  "input": "Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
   "translatedText": "وبشكل أقل وضوحًا، ينطبق الأمر نفسه إذا كان هناك خطأ يؤدي إلى تغيير 1 إلى 0. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -456,7 +456,7 @@
   "end": 469.36
  },
  {
-  "input": "ey point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop. This gives us a rather snazzy way ",
+  "input": "You see, if you add a bit string together twice, it's the same as not having it there at all, basically because in this world 1 plus 1 equals 0.",
   "translatedText": "كما ترى، إذا قمت بإضافة سلسلة صغيرة معًا مرتين، فهذا يعني عدم وجودها على الإطلاق، لأنه في هذا العالم 1 زائد 1 يساوي 0. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -464,7 +464,7 @@
   "end": 477.94
  },
  {
-  "input": "to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation. ",
+  "input": "So adding a copy of this position to the total sum has the same effect as we're moving it.",
   "translatedText": "لذا فإن إضافة نسخة من هذا الموضع إلى المجموع الإجمالي له نفس التأثير الذي نحركه به. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -472,7 +472,7 @@
   "end": 484.3
  },
  {
-  "input": "Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the mes ",
+  "input": "And that effect, again, is that the total result at the bottom here spells out the position of the error.",
   "translatedText": "وهذا التأثير، مرة أخرى، هو أن النتيجة الإجمالية في الأسفل توضح موضع الخطأ. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -480,7 +480,7 @@
   "end": 490.7
  },
  {
-  "input": "sage bit is turned on to a 1, and then collect these positions into one big column and take the XOR. You can probably guess that the four bits sitting at the bottom as a resu ",
+  "input": "To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all of the logic on the receiver's end.",
   "translatedText": "لتوضيح مدى روعة هذا الأمر، اسمحوا لي أن أعرض سطرًا واحدًا من كود بايثون الذي أشرت إليه من قبل، والذي سيلتقط تقريبًا كل المنطق في نهاية المتلقي. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "lt are the same as the four parity checks we've come to know and love, but take a moment to actually think about why exactly. This last column, for example, is counting all of the positions whose last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. ",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "سنبدأ بإنشاء مصفوفة عشوائية مكونة من 16 1 و0 لمحاكاة كتلة البيانات، وسأعطيها بتات الاسم، ولكن بالطبع من الناحية العملية سيكون هذا شيئًا نتلقاه من المرسل، وبدلاً من ذلك نظرًا لكونها عشوائية، فإنها ستحمل 11 بتة بيانات مع 5 بتات تكافؤ. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -496,7 +496,7 @@
   "end": 517.4
  },
  {
-  "input": "If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15. ",
+  "input": "If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
   "translatedText": "إذا قمت باستدعاء الدالة enumerateBits، فإن ما تفعله هو إقران كل من تلك البتات مع فهرس مناظر، في هذه الحالة يعمل من 0 إلى 15. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ht half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit, so these 8 bits already have an even pari Likewise, the next column counts how many positions are in the second parity group, the positions whose second to las ",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "لذا، إذا قمنا بعد ذلك بإنشاء قائمة تدور حول كل هذه الأزواج، الأزواج التي تبدو مثل i، ثم قمنا بسحب قيمة i فقط، فقط الفهرس، حسنًا، الأمر ليس مثيرًا، سنستعيد تلك المؤشرات من 0 إلى 15 . ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on. ",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "ولكن إذا أضفنا شرطًا للقيام بذلك فقط إذا كانت البتة، مما يعني أنه إذا كانت تلك البتة هي 1 وليس 0، فحسنًا فإنها تسحب فقط المواضع التي يتم فيها تشغيل البتة المقابلة. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -520,7 +520,7 @@
   "end": 552.66
  },
  {
-  "input": "ve on the same thing we've been doing. but for right now we're going to assume ",
+  "input": "In this case it looks like those positions are 0, 4, 6, 9, etc.",
   "translatedText": "في هذه الحالة يبدو أن هذه المواضع هي 0، 4، 6، 9، إلخ. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -528,7 +528,7 @@
   "end": 557.96
  },
  {
-  "input": "What we want is to collect together all of those positions, the positions of the bits that are turned on, and then XOR them together. ",
+  "input": "What we want is to collect together all of those positions, the positions of the bits that are turned on, and then XOR them together.",
   "translatedText": "ما نريده هو جمع كل تلك المواضع معًا، مواضع البتات التي تم تشغيلها، ثم XOR معًا. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -536,7 +536,7 @@
   "end": 567.24
  },
  {
-  "input": "The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 000 ",
+  "input": "To do this in Python, let me first import a couple helpful functions.",
   "translatedText": "للقيام بذلك في بايثون، اسمحوا لي أولاً باستيراد وظيفتين مفيدتين. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -544,7 +544,7 @@
   "end": 573.22
  },
  {
-  "input": "That way we can call reduce() on this list, and use the XOR function to reduce it. ",
+  "input": "That way we can call reduce() on this list, and use the XOR function to reduce it.",
   "translatedText": "بهذه الطريقة يمكننا استدعاء الدالة تقليل() في هذه القائمة، واستخدام الدالة XOR لتقليلها. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -552,7 +552,7 @@
   "end": 578.7
  },
  {
-  "input": "es us a really nice way to think about why these four resulting bits at the bottom directly spell out the pos ",
+  "input": "This basically eats its way through the list, taking XORs along the way.",
   "translatedText": "وهذا في الأساس يشق طريقه عبر القائمة، ويأخذ XORs على طول الطريق. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -560,7 +560,7 @@
   "end": 582.68
  },
  {
-  "input": "ition of an error. Let's say you detect an error among the odd columns, and among the right half. It necessarily means the error is somewhere in th ",
+  "input": "If you prefer, you can explicitly write out that XOR function without having to import it from anywhere.",
   "translatedText": "إذا كنت تفضل ذلك، يمكنك كتابة دالة XOR بوضوح دون الحاجة إلى استيرادها من أي مكان. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -568,7 +568,7 @@
   "end": 589.44
  },
  {
-  "input": "So at the moment it looks like if we do this on our random block of 16 bits, it returns 9, which has the binary representation 1001. ",
+  "input": "So at the moment it looks like if we do this on our random block of 16 bits, it returns 9, which has the binary representation 1001.",
   "translatedText": "لذا، في الوقت الحالي، يبدو أننا إذا فعلنا ذلك على الكتلة العشوائية المكونة من 16 بت، فإنها ستُرجع 9، والتي لها التمثيل الثنائي 1001. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0. ",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "لن نفعل ذلك هنا، ولكن يمكنك كتابة دالة يستخدم فيها المرسل هذا التمثيل الثنائي لتعيين وحدات البت التماثلية الأربعة حسب الحاجة، وفي النهاية توصيل هذه الكتلة إلى حالة حيث يؤدي تشغيل هذا السطر من التعليمات البرمجية على القائمة الكاملة للبتات إلى إرجاعها 0. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -584,7 +584,7 @@
   "end": 615.46
  },
  {
-  "input": "This would be considered a well-prepared block. ",
+  "input": "This would be considered a well-prepared block.",
   "translatedText": "سيتم اعتبار هذا كتلة جيدة الإعداد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. ",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "الأمر الرائع هو أنه إذا قمنا بتبديل أي من البتات في هذه القائمة، لمحاكاة خطأ عشوائي من الضوضاء، ثم إذا قمت بتشغيل نفس السطر من التعليمات البرمجية، فإنه يطبع هذا الخطأ. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -600,7 +600,7 @@
   "end": 630.22
  },
  {
-  "input": "an error that changes a 1 to a 0. You see, if you add a bit string together twice, it's the same as ",
+  "input": "Isn't that neat?",
   "translatedText": "أليس هذا أنيق؟ ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any. ",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "يمكنك الحصول على هذه الكتلة فجأة، وتشغيل هذا السطر الفردي عليها، وسيظهر تلقائيًا موضع الخطأ، أو 0 إذا لم يكن هناك أي خطأ. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -616,7 +616,7 @@
   "end": 641.06
  },
  {
-  "input": "And that effect, again, is that the total result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me sh ",
+  "input": "And there's nothing special about the size 16 here.",
   "translatedText": "وليس هناك شيء خاص بخصوص الحجم 16 هنا. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -624,7 +624,7 @@
   "end": 645.2
  },
  {
-  "input": "The same line of code would work if you had a list of, say, 256 bits. ",
+  "input": "The same line of code would work if you had a list of, say, 256 bits.",
   "translatedText": "سيعمل نفس السطر من التعليمات البرمجية إذا كان لديك قائمة، على سبيل المثال، 256 بت. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -632,7 +632,7 @@
   "end": 649.86
  },
  {
-  "input": "ferenced before, which will capture almost all of the logic on the receiver's end. We'll start by creating a random array of 16 ones and zeros to simulate the data block, and I'll go ahead and give it the name bits, but of course in practice this would be something that we're receiving f ",
+  "input": "Needless to say, there is more code to write here, like doing the meta parity check to detect 2-bit errors, but the idea is that almost all of the core logic from our scheme comes down to a single XOR reduction.",
   "translatedText": "وغني عن القول أن هناك المزيد من التعليمات البرمجية التي يجب كتابتها هنا، مثل إجراء فحص التكافؤ التعريفي لاكتشاف أخطاء 2 بت، ولكن الفكرة هي أن كل المنطق الأساسي تقريبًا من مخططنا يعود إلى تقليل XOR واحد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. ",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "الآن، اعتمادًا على راحتك مع الثنائيات وXORs والبرامج بشكل عام، قد تجد هذا المنظور مربكًا بعض الشيء، أو أكثر أناقة وبساطة لدرجة أنك تتساءل لماذا لم نبدأ به من البداية -يذهب. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level. ",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "بشكل عام، من الأسهل التفكير في منظور التحقق من التكافؤ المتعدد عند تنفيذ رموز Hamming في الأجهزة بشكل مباشر جدًا، ومن الأسهل التفكير في منظور XOR عند القيام بذلك في البرامج، من مستوى أعلى نوعًا ما. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -656,7 +656,7 @@
   "end": 690.5
  },
  {
-  "input": "l out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on. In this case it looks like those positions are 0, 4, 6, 9, etc. Remember, what ",
+  "input": "The first one is easiest to actually do by hand, and I think it does a better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the log of the size of the block, or in other words, it grows one bit at a time as the block size doubles.",
   "translatedText": "الأول هو الأسهل في الواقع للقيام به يدويًا، وأعتقد أنه يقوم بعمل أفضل في غرس الحدس الأساسي الكامن وراء كل هذا، وهو أن المعلومات المطلوبة لتحديد موقع خطأ واحد مرتبطة بسجل حجم الكتلة أو بعبارة أخرى، فإنه ينمو قطعة واحدة في كل مرة مع تضاعف حجم الكتلة. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "we want is to collect together all of those positions, the positions of the bits that are turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. ",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "الحقيقة ذات الصلة هنا هي أن هذه المعلومات تتوافق بشكل مباشر مع مقدار التكرار الذي نحتاجه. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -672,7 +672,7 @@
   "end": 716.06
  },
  {
-  "input": "That's really what runs against most people's knee-jerk reaction when they first think about making a message resilient to errors, where usually copying the whole message is the first instinct that comes to mind. ",
+  "input": "That's really what runs against most people's knee-jerk reaction when they first think about making a message resilient to errors, where usually copying the whole message is the first instinct that comes to mind.",
   "translatedText": "وهذا حقًا ما يتعارض مع رد فعل معظم الأشخاص غير المحسوبين عندما يفكرون لأول مرة في جعل رسالة مقاومة للأخطاء، حيث عادةً ما يكون نسخ الرسالة بأكملها هو أول غريزة تتبادر إلى ذهنهم. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix. ",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "وبعد ذلك، بالمناسبة، هناك طريقة أخرى تمامًا حيث ترى أحيانًا رموز هامينج معروضة، حيث تقوم بضرب الرسالة في مصفوفة واحدة كبيرة. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -688,7 +688,7 @@
   "end": 734.0
  },
  {
-  "input": "It's kind of nice because it relates it to the broader family of linear codes, but I think that gives almost no intuition for where it comes from or how it scales. ",
+  "input": "It's kind of nice because it relates it to the broader family of linear codes, but I think that gives almost no intuition for where it comes from or how it scales.",
   "translatedText": "إنه لطيف نوعًا ما لأنه يرتبط بعائلة أوسع من الرموز الخطية، لكنني أعتقد أن هذا لا يعطي أي فكرة تقريبًا عن مصدرها أو كيفية قياسها. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. ",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "وبالحديث عن القياس، قد تلاحظ أن كفاءة هذا المخطط تتحسن فقط عندما نزيد حجم الكتلة. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "looks like if we do this on our random block of 16 bits, it returns 9, which has the binary representation 1001. We won't do it here, but you could write a function wh ",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "على سبيل المثال، رأينا أنه مع 256 بت، فإنك تستخدم 3% فقط من تلك المساحة للتكرار، ويستمر الأمر في التحسن من هناك. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ere the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a state where running th ",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "ومع زيادة عدد البتات المتماثلة واحدة تلو الأخرى، يستمر حجم الكتلة في التضاعف. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits. ",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "وإذا أخذت ذلك إلى أقصى الحدود، يمكن أن يكون لديك كتلة تحتوي، على سبيل المثال، على مليون بت، حيث يمكنك حرفيًا تشغيل 20 سؤالًا مع اختبارات التكافؤ الخاصة بك، وتستخدم 21 بتة فقط. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -728,7 +728,7 @@
   "end": 780.02
  },
  {
-  "input": "And if you step back to think about looking at a million bits and locating a single error, that genuinely feels crazy. ",
+  "input": "And if you step back to think about looking at a million bits and locating a single error, that genuinely feels crazy.",
   "translatedText": "وإذا عدت إلى الوراء للتفكير في النظر إلى مليون بت وتحديد موقع خطأ واحد، فإن هذا يبدو جنونًا حقًا. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that. ",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "المشكلة بالطبع هي أنه مع وجود كتلة أكبر، فإن احتمال رؤية أكثر من خطأ واحد أو اثنين من الأخطاء، ولا تتعامل رموز هامينج مع أي شيء أبعد من ذلك. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -744,7 +744,7 @@
   "end": 797.66
  },
  {
-  "input": "So in practice, what you'd want is to find the right size so that the probability of too many bit flips isn't too high. ",
+  "input": "So in practice, what you'd want is to find the right size so that the probability of too many bit flips isn't too high.",
   "translatedText": "لذا، من الناحية العملية، ما تريده هو العثور على الحجم المناسب بحيث لا يكون احتمال حدوث عدد كبير جدًا من تقلبات البتات مرتفعًا جدًا. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -752,7 +752,7 @@
   "end": 804.3
  },
  {
-  "input": "imulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the positio ",
+  "input": "Also, in practice, errors tend to come in little bursts, which would totally ruin a single block, so one common tactic to help spread out a burst of errors across many different blocks is to interlace those blocks, like this, before they're sent out or stored.",
   "translatedText": "أيضًا، من الناحية العملية، تميل الأخطاء إلى الظهور على شكل دفعات صغيرة، مما قد يؤدي إلى تدمير كتلة واحدة تمامًا، لذا فإن أحد الأساليب الشائعة للمساعدة في نشر موجة من الأخطاء عبر العديد من الكتل المختلفة هو تشبيك تلك الكتل، مثل هذا، قبل أن يتم دمجها إرسالها أو تخزينها. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -760,7 +760,7 @@
   "end": 820.98
  },
  {
-  "input": "Then again, a lot of this is rendered completely moot by more modern codes, like the much more commonly used Reed-Solomon algorithm, which handles burst errors particularly well, and it can be tuned to be resilient to a larger number of errors per block. ",
+  "input": "Then again, a lot of this is rendered completely moot by more modern codes, like the much more commonly used Reed-Solomon algorithm, which handles burst errors particularly well, and it can be tuned to be resilient to a larger number of errors per block.",
   "translatedText": "ثم مرة أخرى، أصبح الكثير من هذا موضع نقاش تمامًا من خلال أكواد أكثر حداثة، مثل خوارزمية Reed-Solomon الأكثر استخدامًا، والتي تتعامل مع أخطاء الاندفاع بشكل جيد، ويمكن ضبطها لتكون مرنة في التعامل مع عدد أكبر من الأخطاء لكل كتلة . ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "But that's a topic for another time. ",
+  "input": "But that's a topic for another time.",
   "translatedText": "ولكن هذا موضوع لوقت آخر. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was. ",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "في كتابه "فن ممارسة العلوم والهندسة"، كان هامينغ صريحًا بشكل رائع حول مدى تعقيد اكتشافه لهذا الرمز. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -784,7 +784,7 @@
   "end": 849.94
  },
  {
-  "input": "He first tried all sorts of different schemes involving organizing the bits into parts of a higher dimensional lattice and strange things like this. ",
+  "input": "He first tried all sorts of different schemes involving organizing the bits into parts of a higher dimensional lattice and strange things like this.",
   "translatedText": "لقد جرب أولاً جميع أنواع المخططات المختلفة التي تتضمن تنظيم البتات إلى أجزاء من شبكة ذات أبعاد أعلى وأشياء غريبة مثل هذه. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -792,7 +792,7 @@
   "end": 857.78
  },
  {
-  "input": "The idea that it might be possible to get parity checks to conspire in a way that spells out the position of an error only came to Hamming when he stepped back after a bunch of other analysis and asked, okay, what is the most efficient I could conceivably be about this? ",
+  "input": "The idea that it might be possible to get parity checks to conspire in a way that spells out the position of an error only came to Hamming when he stepped back after a bunch of other analysis and asked, okay, what is the most efficient I could conceivably be about this?",
   "translatedText": "فكرة أنه قد يكون من الممكن الحصول على فحوصات التكافؤ للتآمر بطريقة توضح موضع الخطأ جاءت إلى هامينج فقط عندما تراجع بعد مجموعة من التحليلات الأخرى وسأل، حسنًا، ما هو الأكثر كفاءة الذي يمكنني فعله من الممكن أن يكون حول هذا؟ ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -800,7 +800,7 @@
   "end": 871.52
  },
  {
-  "input": "He was also candid about how important it was that parity checks were already on his mind, which would have been way less common back in the 1940s than it is today. ",
+  "input": "He was also candid about how important it was that parity checks were already on his mind, which would have been way less common back in the 1940s than it is today.",
   "translatedText": "وكان صريحًا أيضًا بشأن مدى أهمية وجود ضوابط التكافؤ في ذهنه بالفعل، وهو الأمر الذي كان أقل شيوعًا في الأربعينيات مما هو عليه اليوم. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "is perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it ",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "هناك حوالي ست مرات خلال هذا الكتاب يشير فيها إلى مقولة لويس باستور، الحظ يفضل العقل المستعد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -816,7 +816,7 @@
   "end": 888.22
  },
  {
-  "input": "Clever ideas often look deceptively simple in hindsight, which makes them easy to underappreciate. ",
+  "input": "Clever ideas often look deceptively simple in hindsight, which makes them easy to underappreciate.",
   "translatedText": "غالبًا ما تبدو الأفكار الذكية بسيطة بشكل خادع بعد فوات الأوان، مما يجعل من السهل التقليل من قيمتها. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -824,7 +824,7 @@
   "end": 894.3
  },
  {
-  "input": "Right now my honest hope is that Hamming codes, or at least the possibility of such codes, feels almost obvious to you. ",
+  "input": "Right now my honest hope is that Hamming codes, or at least the possibility of such codes, feels almost obvious to you.",
   "translatedText": "في الوقت الحالي، أملي الصادق هو أن تكون رموز هامينج، أو على الأقل إمكانية وجود مثل هذه الرموز، واضحة تقريبًا بالنسبة لك. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't. ",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "لكن لا ينبغي أن تخدع نفسك بالاعتقاد بأنها واضحة بالفعل، لأنها بالتأكيد ليست كذلك. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -840,7 +840,7 @@
   "end": 906.82
  },
  {
-  "input": ", with four yes or no questions, we have 16 possible outcomes for our parity checks, and at first that feels perfect for pinpointing 1 out of 16 positions in the block, but you also need to communicate a 17th outcome, the no error condition. The first one is easiest to actually do by hand, and I think it does a better job instilling the core intuition underlying all of this, ",
+  "input": "Part of the reason that clever ideas look deceptively easy is that we only ever see the final result, cleaning up what was messy, never mentioning all of the wrong turns, underselling just how vast the space of explorable possibilities is at the start of a problem solving process, all of that.",
   "translatedText": "جزء من السبب الذي يجعل الأفكار الذكية تبدو سهلة بشكل خادع هو أننا لا نرى سوى النتيجة النهائية، وننظف ما كان فوضويًا، ولا نذكر أبدًا كل المنعطفات الخاطئة، ونقلل من مدى اتساع مساحة الإمكانيات القابلة للاستكشاف في بداية المشكلة. عملية الحل، كل ذلك. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -848,7 +848,7 @@
   "end": 922.86
  },
  {
-  "input": "which is that the information required to locate a single error is relat ",
+  "input": "But this is true in general.",
   "translatedText": "ولكن هذا صحيح بشكل عام. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -856,7 +856,7 @@
   "end": 924.9
  },
  {
-  "input": "ed to the log of the size of the block, or in other words, it grows one bit at a time as the block size doubles. The relevant fact here i ",
+  "input": "I think for some special inventions, there's a second, deeper reason that we underappreciate them.",
   "translatedText": "أعتقد أنه بالنسبة لبعض الاختراعات الخاصة، هناك سبب ثانٍ وأعمق لعدم تقديرنا لها. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -864,7 +864,7 @@
   "end": 930.04
  },
  {
-  "input": "Thinking of information in terms of bits had only really coalesced into a full theory by 1948, with Claude Shannon's seminal paper on information theory. ",
+  "input": "Thinking of information in terms of bits had only really coalesced into a full theory by 1948, with Claude Shannon's seminal paper on information theory.",
   "translatedText": "إن التفكير في المعلومات من حيث البتات قد اندمج فعليًا في نظرية كاملة بحلول عام 1948، مع ورقة كلود شانون الأساسية حول نظرية المعلومات. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -872,7 +872,7 @@
   "end": 938.64
  },
  {
-  "input": "block is even, just like a normal parity check. Now, if there's a single bit error, then ",
+  "input": "This was essentially concurrent with when Hamming developed his algorithm.",
   "translatedText": "كان هذا متزامنًا بشكل أساسي مع قيام هامينج بتطوير خوارزميته. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "the parity of the full block toggles to be odd, but we would catch that anyway thanks to the four error-correcting checks. However, if there's two errors, then the overall parity is going to toggle back to be And then, by the way, there is this whole other way that you s ",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "كانت هذه هي نفس الورقة التأسيسية التي أظهرت، إلى حد ما، أن التصحيح الفعال للأخطاء أمر ممكن دائمًا، بغض النظر عن مدى احتمالية قلب البتات، على الأقل من الناحية النظرية. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -888,7 +888,7 @@
   "end": 952.9
  },
  {
-  "input": "Shannon and Hamming, by the way, shared an office in Bell Labs, despite working on very different things, which hardly seems coincidental here. ",
+  "input": "Shannon and Hamming, by the way, shared an office in Bell Labs, despite working on very different things, which hardly seems coincidental here.",
   "translatedText": "بالمناسبة، كان شانون وهامينج يشتركان في مكتب واحد في Bell Labs، على الرغم من العمل على أشياء مختلفة تمامًا، وهو الأمر الذي لا يبدو من قبيل الصدفة هنا. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "multiply the message by one big matrix. It's kind of nice because it relates it to the broader family of linear codes, but I think that gives almost no intuition for where it comes from or how it scales. ",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "بعد مرور عدة عقود، وفي هذه الأيام، الكثير منا منغمسون جدًا في التفكير في أجزاء ومعلومات، مما يجعل من السهل التغاضي عن مدى تميز طريقة التفكير هذه. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -904,7 +904,7 @@
   "end": 972.34
  },
  {
-  "input": "Ironically, the ideas that most profoundly shape the ways that a future generation thinks will end up looking to that future generation simpler than they really are. ",
+  "input": "Ironically, the ideas that most profoundly shape the ways that a future generation thinks will end up looking to that future generation simpler than they really are.",
   "translatedText": "ومن عجيب المفارقات أن الأفكار التي تشكل بشكل أعمق الطرق التي يفكر بها جيل المستقبل ستنتهي في النهاية إلى النظر إلى جيل المستقبل بشكل أبسط مما هو عليه بالفعل. ",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/bengali/sentence_translations.json b/2020/hamming-codes-2/bengali/sentence_translations.json
index 1fa77c899..98de9f5a6 100644
--- a/2020/hamming-codes-2/bengali/sentence_translations.json
+++ b/2020/hamming-codes-2/bengali/sentence_translations.json
@@ -1,6 +1,6 @@
 [
  {
-  "input": "I'm assuming that everybody here is coming from part 1. ",
+  "input": "I'm assuming that everybody here is coming from part 1.",
   "translatedText": "আমি অনুমান করছি যে এখানে সবাই পার্ট 1 থেকে আসছে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it. ",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "আমরা হ্যামিং কোড সম্পর্কে কথা বলছিলাম, ডেটার একটি ব্লক তৈরি করার একটি উপায় যেখানে বেশিরভাগ বিট একটি অর্থপূর্ণ বার্তা বহন করে, যখন কয়েকটি অন্য এক ধরণের অপ্রয়োজনীয়তা হিসাবে কাজ করে, এমনভাবে যাতে কোনও বিট ফ্লিপ হয়ে যায়, হয় একটি বার্তা।বিট বা রিডানডেন্সি বিট, এই ব্লকের যেকোনো কিছু, একজন রিসিভার শনাক্ত করতে সক্ষম হবে যে একটি ত্রুটি ছিল এবং কীভাবে এটি ঠিক করা যায়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error. ",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "সেখানে উপস্থাপিত মূল ধারণাটি ছিল কিভাবে একাধিক প্যারিটি চেক ব্যবহার করে বাইনারি অনুসন্ধানের জন্য আপনার ত্রুটির দিকে যেতে হবে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -24,7 +24,7 @@
   "end": 27.16
  },
  {
-  "input": "In that video the goal was to make Hamming codes feel as hands-on and rediscoverable as possible. ",
+  "input": "In that video the goal was to make Hamming codes feel as hands-on and rediscoverable as possible.",
   "translatedText": "সেই ভিডিওতে লক্ষ্য ছিল হ্যামিং কোডগুলিকে যতটা সম্ভব হ্যান্ড-অন এবং পুনরাবিষ্কারযোগ্য মনে করা।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -32,7 +32,7 @@
   "end": 34.6
  },
  {
-  "input": "hat there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error. In that video, the goal was to make Hamming codes feel as hands-on and rediscoverable as possible. But as ",
+  "input": "But as you start to think about actually implementing this, either in software or hardware, that framing may actually undersell how elegant these codes really are.",
   "translatedText": "কিন্তু আপনি যখন সফ্টওয়্যার বা হার্ডওয়্যারে বাস্তবিকই এটি বাস্তবায়নের কথা ভাবতে শুরু করেন, সেই ফ্রেমিং আসলে এই কোডগুলি কতটা মার্জিত তা বোঝা যায়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -40,7 +40,7 @@
   "end": 43.46
  },
  {
-  "input": "You might think that you need to write an algorithm that keeps track of all the possible error locations and cuts that group in half with each check, but it's actually way, way simpler than that. ",
+  "input": "You might think that you need to write an algorithm that keeps track of all the possible error locations and cuts that group in half with each check, but it's actually way, way simpler than that.",
   "translatedText": "আপনি ভাবতে পারেন যে আপনাকে এমন একটি অ্যালগরিদম লিখতে হবে যা সমস্ত সম্ভাব্য ত্রুটির অবস্থানের ট্র্যাক রাখে এবং প্রতিটি চেকের সাথে সেই গ্রুপটিকে অর্ধেক করে দেয়, তবে এটি আসলে তার চেয়ে সহজ উপায়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -48,7 +48,7 @@
   "end": 53.48
  },
  {
-  "input": "If you read out the answers to the four parity checks we did in the last video, all as 1s and 0s instead of yeses and nos, it literally spells out the position of the error in binary. ",
+  "input": "If you read out the answers to the four parity checks we did in the last video, all as 1s and 0s instead of yeses and nos, it literally spells out the position of the error in binary.",
   "translatedText": "আপনি যদি শেষ ভিডিওতে আমরা যে চারটি প্যারিটি চেকের উত্তরগুলি পড়েছিলাম, হ্যাঁ এবং না-এর পরিবর্তে 1s এবং 0s হিসাবে, এটি আক্ষরিক অর্থে বাইনারিতে ত্রুটির অবস্থানটি বানান করে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "you read out the answers to the four parity checks we did in the last video, all as ones and zeros instead of yeses and nos, it literally spells out ",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "উদাহরণস্বরূপ, বাইনারিতে 7 নম্বরটি 0111-এর মতো দেখায়, মূলত বলছে যে এটি 4 যোগ 2 যোগ 1।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last. ",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "এবং লক্ষ্য করুন যেখানে অবস্থান 7 বসে, এটি আমাদের সমতা গোষ্ঠীর প্রথমটিকে প্রভাবিত করে, এবং দ্বিতীয়টি এবং তৃতীয়টি, কিন্তু শেষ নয়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day. The goal here is to give you a very thorough understanding of one of the earlie ",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "সুতরাং নীচে থেকে উপরে এই চারটি চেকের ফলাফল পড়া প্রকৃতপক্ষে ত্রুটির অবস্থানটি বানান করে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -80,7 +80,7 @@
   "end": 87.54
  },
  {
-  "input": "st examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity groups, and the second, and the third, but not the last. So reading the results of those four checks ",
+  "input": "There's nothing special about the example 7, this works in general, and this makes the logic for implementing the whole scheme in hardware shockingly simple.",
   "translatedText": "উদাহরণ 7 সম্পর্কে বিশেষ কিছু নেই, এটি সাধারণভাবে কাজ করে, এবং এটি হার্ডওয়্যারে পুরো স্কিমটি বাস্তবায়নের যুক্তিকে চমকপ্রদভাবে সহজ করে তোলে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -88,7 +88,7 @@
   "end": 95.82
  },
  {
-  "input": "Now if you want to see why this magic happens, take these 16 index labels for our positions, but instead of writing them in base 10, let's write them all in binary, running from 0000 up to 1111. ",
+  "input": "Now if you want to see why this magic happens, take these 16 index labels for our positions, but instead of writing them in base 10, let's write them all in binary, running from 0000 up to 1111.",
   "translatedText": "এখন আপনি যদি দেখতে চান কেন এই জাদুটি ঘটে, তাহলে আমাদের অবস্থানের জন্য এই 16টি সূচক লেবেল নিন, তবে সেগুলিকে বেস 10-এ না লিখে, আসুন সেগুলিকে 0000 থেকে 1111 পর্যন্ত বাইনারিতে লিখি।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent. ",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "যেহেতু আমরা এই বাইনারি লেবেলগুলিকে তাদের বাক্সে আবার রাখি, আমাকে জোর দিয়ে বলতে দিন যে তারা আসলে যে ডেটা পাঠানো হচ্ছে তার থেকে আলাদা।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from. ",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "এগুলি আপনাকে এবং আমাকে বুঝতে সাহায্য করার জন্য একটি ধারণাগত লেবেল ছাড়া আর কিছুই নয় যে চারটি সমতা গোষ্ঠী কোথা থেকে এসেছে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary. ",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "আমরা যা কিছু দেখছি তা বাইনারিতে বর্ণনা করার কমনীয়তা হয়তো বাইনারিতে বর্ণনা করা হচ্ছে এমন সব কিছু থাকার বিভ্রান্তির দ্বারা হ্রাস করা হয়েছে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -120,7 +120,7 @@
   "end": 132.36
  },
  {
-  "input": "0, let's write them all in binary, running from 0000 up to 1111. ask feels at the star ",
+  "input": "It's worth it, though.",
   "translatedText": "এটা মূল্য, যদিও. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -128,7 +128,7 @@
   "end": 134.12
  },
  {
-  "input": "Focus your attention just on that last bit of all of these labels, and then highlight the positions where that final bit is a 1. ",
+  "input": "Focus your attention just on that last bit of all of these labels, and then highlight the positions where that final bit is a 1.",
   "translatedText": "এই সমস্ত লেবেলের শেষ বিটটিতে আপনার মনোযোগ কেন্দ্রীভূত করুন এবং তারপর সেই অবস্থানগুলিকে হাইলাইট করুন যেখানে সেই চূড়ান্ত বিটটি 1।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1? ",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "আমরা কি পেতে আমাদের চার প্যারিটি গ্রুপের প্রথম, যার মানে আপনি যে প্রথম চেক ব্যাখ্যা করতে পারেন জিজ্ঞাসা হিসাবে, আরে, যদি একটি ত্রুটি আছে, যে ত্রুটির অবস্থানে চূড়ান্ত বিট একটি 1? ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -144,7 +144,7 @@
   "end": 155.74
  },
  {
-  "input": "Similarly, if you focus on the second to last bit, and highlight all the positions where that's a 1, you get the second parity group from our scheme. ",
+  "input": "Similarly, if you focus on the second to last bit, and highlight all the positions where that's a 1, you get the second parity group from our scheme.",
   "translatedText": "একইভাবে, আপনি যদি সেকেন্ড টু লাস্ট বিটের উপর ফোকাস করেন এবং সমস্ত পজিশন হাইলাইট করেন যেখানে সেটি 1, আপনি আমাদের স্কিম থেকে দ্বিতীয় প্যারিটি গ্রুপ পাবেন।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -152,7 +152,7 @@
   "end": 166.16
  },
  {
-  "input": "ly spelled words. Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. ",
+  "input": "In other words, that second check is asking, hey, me again, if there's an error, is the second to last bit of that position a 1?",
   "translatedText": "অন্য কথায়, যে দ্বিতীয় চেক জিজ্ঞাসা করা হয়, আরে, আমাকে আবার, যদি একটি ত্রুটি আছে, যে অবস্থানের শেষ বিট দ্বিতীয় একটি 1? ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "And so on. ",
+  "input": "And so on.",
   "translatedText": "ইত্যাদি।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -168,7 +168,7 @@
   "end": 176.9
  },
  {
-  "input": "The third parity check covers every position whose third to last bit is turned on, and the last one covers the last eight positions, those ones whose highest order bit is a 1. ",
+  "input": "The third parity check covers every position whose third to last bit is turned on, and the last one covers the last eight positions, those ones whose highest order bit is a 1.",
   "translatedText": "তৃতীয় প্যারিটি চেক প্রতিটি অবস্থানকে কভার করে যার তৃতীয় থেকে শেষ বিট চালু আছে এবং শেষটি শেষ আটটি অবস্থানকে কভার করে, যাদের সর্বোচ্চ ক্রম বিট হল 1।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -176,7 +176,7 @@
   "end": 188.74
  },
  {
-  "input": "everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary. ",
+  "input": "Everything we did earlier is the same as answering these four questions, which in turn is the same as spelling out a position in binary.",
   "translatedText": "আমরা আগে যা করেছি তা এই চারটি প্রশ্নের উত্তর দেওয়ার মতোই, যা বাইনারিতে একটি অবস্থানের বানান করার মতোই।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -184,7 +184,7 @@
   "end": 197.74
  },
  {
-  "input": "It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where tha ",
+  "input": "I hope this makes two things clearer.",
   "translatedText": "আমি আশা করি এটি দুটি জিনিস পরিষ্কার করে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "t final bit is a 1. What we get is the first of our four parity groups, which means that you can interpret that first check as asking, hey, if there's an err ",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "প্রথমটি হল দুটির বড় শক্তির আকারগুলিকে ব্লক করার পদ্ধতিগতভাবে সাধারণীকরণ কিভাবে করা যায়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -200,7 +200,7 @@
   "end": 206.46
  },
  {
-  "input": "If it takes more bits to describe each position, like six bits to describe 64 spots, then each of those bits gives you one of the parity groups that we need to check. ",
+  "input": "If it takes more bits to describe each position, like six bits to describe 64 spots, then each of those bits gives you one of the parity groups that we need to check.",
   "translatedText": "যদি প্রতিটি অবস্থান বর্ণনা করতে আরও বিট লাগে, যেমন 64টি দাগ বর্ণনা করতে ছয় বিট, তাহলে সেই বিটগুলির প্রতিটি আপনাকে প্যারিটি গ্রুপগুলির একটি দেয় যা আমাদের পরীক্ষা করতে হবে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -208,7 +208,7 @@
   "end": 216.68
  },
  {
-  "input": "maybe at the end or something like that, but as you'll see, having them sit in positions which are powers of 2 allows for something that's really elegant by the end. ",
+  "input": "Those of you who watched the chessboard puzzle I did with Matt Parker might find all this exceedingly familiar.",
   "translatedText": "আপনারা যারা ম্যাট পার্কারের সাথে দাবাবোর্ডের ধাঁধা দেখেছেন তারা হয়তো এই সব অতি পরিচিত মনে করতে পারেন।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -216,7 +216,7 @@
   "end": 223.18
  },
  {
-  "input": "It's the same core logic, but solving a different problem, and applied to a 64-squared chessboard. ",
+  "input": "It's the same core logic, but solving a different problem, and applied to a 64-squared chessboard.",
   "translatedText": "এটি একই মূল যুক্তি, কিন্তু একটি ভিন্ন সমস্যা সমাধান করে, এবং একটি 64-বর্গীয় দাবাবোর্ডে প্রয়োগ করা হয়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -224,7 +224,7 @@
   "end": 228.78
  },
  {
-  "input": "The second thing I hope this makes clear is why our parity bits are sitting in the positions that are powers of two, for example 1, 2, 4, and 8. ",
+  "input": "The second thing I hope this makes clear is why our parity bits are sitting in the positions that are powers of two, for example 1, 2, 4, and 8.",
   "translatedText": "দ্বিতীয় জিনিসটি আমি আশা করি এটি পরিষ্কার করে দেয় যে কেন আমাদের প্যারিটি বিট দুটির শক্তি, উদাহরণস্বরূপ 1, 2, 4 এবং 8 অবস্থানে বসে আছে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -232,7 +232,7 @@
   "end": 237.32
  },
  {
-  "input": "at goes on at position 0, but don't worry about that for now. The third parity check covers every position whose third to last bit is turned ",
+  "input": "These are the positions whose binary representation has just a single bit turned on.",
   "translatedText": "এই হল সেই পজিশন যার বাইনারি রিপ্রেজেন্টেশন মাত্র একটি বিট চালু হয়েছে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups. ",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "এর মানে কি সেই প্যারিটি বিটগুলির প্রতিটি একটির ভিতরে বসে এবং চারটি প্যারিটি গ্রুপের মধ্যে একটি মাত্র।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -248,7 +248,7 @@
   "end": 249.46
  },
  {
-  "input": "You can also see this in larger examples, where no matter how big you get, each parity bit conveniently touches only one of the groups. ",
+  "input": "You can also see this in larger examples, where no matter how big you get, each parity bit conveniently touches only one of the groups.",
   "translatedText": "আপনি আরও বড় উদাহরণে এটি দেখতে পারেন, যেখানে আপনি যত বড়ই হোন না কেন, প্রতিটি প্যারিটি বিট সুবিধাজনকভাবে শুধুমাত্র একটি গ্রুপকে স্পর্শ করে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -256,7 +256,7 @@
   "end": 259.34
  },
  {
-  "input": "Once you understand that these parity checks that we've focused so much of our time on are nothing more than a clever way to spell out the position of an error in binary, then we can draw a connection with a different way to think about hamming codes, one that is arguably a lot simpler and more elegant, and which can basically be written down with a single line of code. ",
+  "input": "Once you understand that these parity checks that we've focused so much of our time on are nothing more than a clever way to spell out the position of an error in binary, then we can draw a connection with a different way to think about hamming codes, one that is arguably a lot simpler and more elegant, and which can basically be written down with a single line of code.",
   "translatedText": "একবার আপনি বুঝতে পেরেছেন যে এই সমতা পরীক্ষাগুলি যেগুলির উপর আমরা আমাদের অনেক সময় ফোকাস করেছি তা বাইনারিতে একটি ত্রুটির অবস্থানটি বানান করার একটি চতুর উপায় ছাড়া আর কিছুই নয়, তাহলে আমরা হ্যামিং সম্পর্কে চিন্তা করার একটি ভিন্ন উপায়ের সাথে একটি সংযোগ আঁকতে পারি।কোড, যেটি তর্কাতীতভাবে অনেক সহজ এবং মার্জিত, এবং যা মূলত কোডের একটি লাইন দিয়ে লেখা যেতে পারে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -264,7 +264,7 @@
   "end": 283.24
  },
  {
-  "input": "It's based on the XOR function. ",
+  "input": "It's based on the XOR function.",
   "translatedText": "এটি XOR ফাংশনের উপর ভিত্তি করে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -272,7 +272,7 @@
   "end": 285.5
  },
  {
-  "input": "f 1s in the message is an even number. So for example right now, that total number of 1s is If it takes more bits to describe each p ",
+  "input": "XOR, for those of you who don't know, stands for exclusive or.",
   "translatedText": "XOR, আপনারা যারা জানেন না তাদের জন্য, একচেটিয়া বা।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "osition, like six bits to describe 64 spots, then each of those bits gives you one of the parity groups that we need to check. that special bit to be a 1, making the count even. But if the block had already started off with a ",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "যখন আপনি দুটি বিটের XOR নেন, তখন এটি একটি 1 ফেরত দেয় যদি সেই বিটের যেকোনো একটি চালু থাকে, তবে উভয়টি চালু বা বন্ধ থাকলে নয়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "Phrased differently, it's the parity of these two bits. ",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "ভিন্নভাবে বাক্যাংশ, এটি এই দুটি বিটের সমতা।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -296,7 +296,7 @@
   "end": 302.98
  },
  {
-  "input": "it would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core ",
+  "input": "As a math person, I prefer to think about it as addition mod 2.",
   "translatedText": "একজন গণিত ব্যক্তি হিসাবে, আমি এটিকে সংযোজন মোড 2 হিসাবে ভাবতে পছন্দ করি।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -304,7 +304,7 @@
   "end": 306.76
  },
  {
-  "input": "logic, but solving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity bits are sitti ",
+  "input": "We also commonly talk about the XOR of two different bit strings, which basically does this component by component.",
   "translatedText": "এছাড়াও আমরা সাধারণত দুটি ভিন্ন বিট স্ট্রিং এর XOR সম্পর্কে কথা বলি, যা মূলত এই উপাদানটি কম্পোনেন্ট দ্বারা করে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "It's like addition, but where you never carry. ",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "এটা যোগ মত, কিন্তু যেখানে আপনি বহন না. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -320,7 +320,7 @@
   "end": 315.72
  },
  {
-  "input": "Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. ",
+  "input": "Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2.",
   "translatedText": "আবার, গাণিতিকভাবে আরো বেশি ঝোঁক এটিকে দুটি ভেক্টর যোগ করা এবং মোড 2 হ্রাস করার মত ভাবতে পছন্দ করতে পারে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -328,7 +328,7 @@
   "end": 322.48
  },
  {
-  "input": "of two, for example 1, 2, 4, and 8. These are the positions whose binary representation has just a single bit turned on. d say the parity is 0 or 1, which is typically more helpful once you start doing math with the idea. And this special bit that the sender uses to con ",
+  "input": "If you open up some Python right now and apply the caret operation between two integers, this is what it's doing but to the bit representations of those numbers under the hood.",
   "translatedText": "আপনি যদি এখনই কিছু পাইথন খুলেন এবং দুটি পূর্ণসংখ্যার মধ্যে ক্যারেট অপারেশনটি প্রয়োগ করেন, তবে হুডের নীচে সেই সংখ্যাগুলির বিট উপস্থাপনা ছাড়া এটিই করছে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "trol the parity is called the parity bit. And actually, we should be clear, if the receiver sees an odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure tha ",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "আপনার এবং আমার জন্য মূল বিষয় হল যে অনেকগুলি ভিন্ন বিট স্ট্রিংগুলির XOR নেওয়া কার্যকরভাবে একগুচ্ছ পৃথক গোষ্ঠীর প্যারোডিগুলি গণনা করার একটি উপায়, যেমন কলামগুলির সাথে, সমস্ত এককভাবে পড়ে যায়৷ এটি আমাদের হ্যামিং কোড অ্যালগরিদম থেকে মাল্টিপল প্যারিটি চেক সম্পর্কে চিন্তা করার জন্য একটি সহজ উপায় দেয় কারণ সবগুলিকে এক একক অপারেশনে একসাথে প্যাকেজ করা হচ্ছে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation. ",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -352,7 +352,7 @@
   "end": 358.78
  },
  {
-  "input": "Though at first glance it does look very different. ",
+  "input": "Though at first glance it does look very different.",
   "translatedText": "যদিও প্রথম নজরে এটি খুব আলাদা দেখায়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -360,7 +360,7 @@
   "end": 362.18
  },
  {
-  "input": "Specifically write down the 16 positions in binary, like we had before, and now highlight the positions where the message bit is turned on to a 1, and then collect these positions into one big column and take the XOR. ",
+  "input": "Specifically write down the 16 positions in binary, like we had before, and now highlight the positions where the message bit is turned on to a 1, and then collect these positions into one big column and take the XOR.",
   "translatedText": "বিশেষভাবে বাইনারিতে 16টি পজিশন লিখুন, যেমনটি আমাদের আগে ছিল, এবং এখন সেই পজিশনগুলিকে হাইলাইট করুন যেখানে মেসেজ বিটটি 1 এ চালু হয়েছে এবং তারপর এই পজিশনগুলিকে একটি বড় কলামে সংগ্রহ করুন এবং XOR নিন।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -368,7 +368,7 @@
   "end": 377.1
  },
  {
-  "input": "You can probably guess that the 4 bits sitting at the bottom as a result are the same as the 4 parity checks we've come to know and love, but take a moment to actually think about why exactly. ",
+  "input": "You can probably guess that the 4 bits sitting at the bottom as a result are the same as the 4 parity checks we've come to know and love, but take a moment to actually think about why exactly.",
   "translatedText": "আপনি সম্ভবত অনুমান করতে পারেন যে ফলস্বরূপ নীচে বসে থাকা 4টি বিটগুলি 4টি প্যারিটি চেকের মতো যা আমরা জেনেছি এবং পছন্দ করেছি, তবে ঠিক কেন তা নিয়ে ভাবতে একটু সময় নিন।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -376,7 +376,7 @@
   "end": 389.2
  },
  {
-  "input": "This last column, for example, is counting all of the positions whose last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. ",
+  "input": "This last column, for example, is counting all of the positions whose last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group.",
   "translatedText": "উদাহরণস্বরূপ, এই শেষ কলামটি সেই সমস্ত অবস্থানগুলিকে গণনা করছে যার শেষ বিটটি হল 1, কিন্তু আমরা ইতিমধ্যে শুধুমাত্র হাইলাইট করা অবস্থানগুলিতে সীমাবদ্ধ, তাই এটি কার্যকরভাবে গণনা করছে যে প্রথম প্যারিটি গ্রুপ থেকে কতগুলি হাইলাইট করা অবস্থান এসেছে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is ",
+  "input": "Does that make sense?",
   "translatedText": "যে জানার জন্য? ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "turned on, but not if both are turned on or if both are turned off. Phrased differently, it's the parity of these two bits. full message down to a single bit, what they give us is a powerful building block for more sophisticated schemes. ",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "একইভাবে, পরবর্তী কলামটি দ্বিতীয় প্যারিটি গ্রুপে কতগুলি অবস্থান রয়েছে তা গণনা করে, যে অবস্থানগুলির দ্বিতীয় থেকে শেষ বিটটি 1, এবং যেগুলিকে হাইলাইট করা হয়েছে, ইত্যাদি।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -400,7 +400,7 @@
   "end": 420.0
  },
  {
-  "input": "It's really just a small shift in perspective on the same thing we've been doing. ",
+  "input": "It's really just a small shift in perspective on the same thing we've been doing.",
   "translatedText": "এটা সত্যিই দৃষ্টিকোণ একটি ছোট পরিবর্তন একই জিনিস আমরা করছি করছি. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -408,7 +408,7 @@
   "end": 423.96
  },
  {
-  "input": "e also commonly talk about the XOR of two different bit s ",
+  "input": "And so you know where it goes from here.",
   "translatedText": "এবং তাই আপনি জানেন যে এটি এখান থেকে কোথায় যায়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -416,7 +416,7 @@
   "end": 429.6
  },
  {
-  "input": "The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000. ",
+  "input": "The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
   "translatedText": "যোগফল 0000 হবে তা নিশ্চিত করতে কিছু বিশেষ প্যারিটি বিট টগল করার জন্য প্রেরক দায়ী।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error. ",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "এখন একবার আমাদের কাছে এটি এইরকম হয়ে গেলে, এটি আমাদেরকে চিন্তা করার একটি সত্যিই সুন্দর উপায় দেয় কেন নীচের এই চারটি ফলে বিটগুলি একটি ত্রুটির অবস্থানকে সরাসরি বানান করে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "Let's say some bit in this block gets toggled from a 0 to a 1. ",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "ধরা যাক এই ব্লকের কিছু অংশ 0 থেকে 1 থেকে টগল হয়ে গেছে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. ",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "এর মানে হল যে সেই বিটের অবস্থানটি এখন মোট XOR-তে অন্তর্ভুক্ত হতে চলেছে, যা যোগফলকে 0 থেকে পরিবর্তন করে এই নতুন অন্তর্ভুক্ত মান, ত্রুটির অবস্থানের পরিবর্তে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -448,7 +448,7 @@
   "end": 463.82
  },
  {
-  "input": "Slightly less obviously, the same is true if there's an error that changes a 1 to a 0. ",
+  "input": "Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
   "translatedText": "সামান্য কম স্পষ্টতই, একই কথা সত্য যদি কোনো ত্রুটি থাকে যা 1 থেকে 0 পরিবর্তন করে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -456,7 +456,7 @@
   "end": 469.36
  },
  {
-  "input": "ey point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop. This gives us a rather snazzy way ",
+  "input": "You see, if you add a bit string together twice, it's the same as not having it there at all, basically because in this world 1 plus 1 equals 0.",
   "translatedText": "আপনি দেখতে পাচ্ছেন, আপনি যদি দুইবার একসাথে কিছুটা স্ট্রিং যোগ করেন, তবে এটি সেখানে না থাকার মতই, মূলত কারণ এই পৃথিবীতে 1 যোগ 1 সমান 0।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -464,7 +464,7 @@
   "end": 477.94
  },
  {
-  "input": "to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation. ",
+  "input": "So adding a copy of this position to the total sum has the same effect as we're moving it.",
   "translatedText": "সুতরাং মোট যোগফলের সাথে এই অবস্থানের একটি অনুলিপি যোগ করলে একই প্রভাব রয়েছে যেভাবে আমরা এটি স্থানান্তর করছি।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -472,7 +472,7 @@
   "end": 484.3
  },
  {
-  "input": "Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the mes ",
+  "input": "And that effect, again, is that the total result at the bottom here spells out the position of the error.",
   "translatedText": "এবং সেই প্রভাব, আবার, এখানে নীচের মোট ফলাফলটি ত্রুটির অবস্থানকে বানান করে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -480,7 +480,7 @@
   "end": 490.7
  },
  {
-  "input": "sage bit is turned on to a 1, and then collect these positions into one big column and take the XOR. You can probably guess that the four bits sitting at the bottom as a resu ",
+  "input": "To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all of the logic on the receiver's end.",
   "translatedText": "এটি কতটা মার্জিত তা বোঝাতে, আমি আগে উল্লেখ করেছি পাইথন কোডের একটি লাইন দেখাই, যা রিসিভারের প্রায় সমস্ত যুক্তি ক্যাপচার করবে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "lt are the same as the four parity checks we've come to know and love, but take a moment to actually think about why exactly. This last column, for example, is counting all of the positions whose last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. ",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "আমরা ডাটা ব্লকের অনুকরণের জন্য 16 1s এবং 0s এর একটি এলোমেলো অ্যারে তৈরি করে শুরু করব, এবং আমি এটির নাম বিট দেব, তবে অবশ্যই বাস্তবে এটি এমন কিছু হবে যা আমরা একজন প্রেরকের কাছ থেকে পাচ্ছি এবং পরিবর্তে এলোমেলো হওয়ায় এটি 5 প্যারিটি বিটের সাথে 11টি ডেটা বিট বহন করবে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -496,7 +496,7 @@
   "end": 517.4
  },
  {
-  "input": "If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15. ",
+  "input": "If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
   "translatedText": "যদি আমি ফাংশনটিকে গণনা বিট বলি, তবে এটি যা করে তা হল প্রতিটি বিটকে একটি সংশ্লিষ্ট সূচকের সাথে একত্রিত করে, এই ক্ষেত্রে 0 থেকে 15 পর্যন্ত চলছে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ht half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit, so these 8 bits already have an even pari Likewise, the next column counts how many positions are in the second parity group, the positions whose second to las ",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "তাই যদি আমরা একটি তালিকা তৈরি করি যা এই সমস্ত জোড়ার উপর লুপ করে, যে জোড়াগুলি i এর মত দেখায়, এবং তারপরে আমরা শুধু i এর মান, শুধু সূচকটি বের করে ফেলি, ভাল এটি এত উত্তেজনাপূর্ণ নয়, আমরা 0 থেকে 15 সূচকগুলি ফিরে পাই।. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on. ",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "কিন্তু যদি আমরা শর্ত যোগ করি যে এটি শুধুমাত্র যদি বিট করতে হয়, মানে সেই বিটটি যদি 1 হয় এবং 0 না হয়, তাহলে এটি শুধুমাত্র সেই অবস্থানগুলিকে বের করে দেয় যেখানে সংশ্লিষ্ট বিটটি চালু করা হয়েছে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -520,7 +520,7 @@
   "end": 552.66
  },
  {
-  "input": "ve on the same thing we've been doing. but for right now we're going to assume ",
+  "input": "In this case it looks like those positions are 0, 4, 6, 9, etc.",
   "translatedText": "এই ক্ষেত্রে মনে হচ্ছে সেই অবস্থানগুলি হল 0, 4, 6, 9, ইত্যাদি।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -528,7 +528,7 @@
   "end": 557.96
  },
  {
-  "input": "What we want is to collect together all of those positions, the positions of the bits that are turned on, and then XOR them together. ",
+  "input": "What we want is to collect together all of those positions, the positions of the bits that are turned on, and then XOR them together.",
   "translatedText": "আমরা যা চাই তা হল সেই সমস্ত পজিশন, বিটগুলির অবস্থানগুলি যেগুলি চালু করা হয়েছে, এবং তারপরে সেগুলিকে একসাথে সংগ্রহ করা।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -536,7 +536,7 @@
   "end": 567.24
  },
  {
-  "input": "The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 000 ",
+  "input": "To do this in Python, let me first import a couple helpful functions.",
   "translatedText": "পাইথনে এটি করতে, আমাকে প্রথমে কয়েকটি সহায়ক ফাংশন আমদানি করতে দিন।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -544,7 +544,7 @@
   "end": 573.22
  },
  {
-  "input": "That way we can call reduce() on this list, and use the XOR function to reduce it. ",
+  "input": "That way we can call reduce() on this list, and use the XOR function to reduce it.",
   "translatedText": "এইভাবে আমরা এই তালিকায় reduce() কল করতে পারি এবং এটি কমাতে XOR ফাংশন ব্যবহার করতে পারি।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -552,7 +552,7 @@
   "end": 578.7
  },
  {
-  "input": "es us a really nice way to think about why these four resulting bits at the bottom directly spell out the pos ",
+  "input": "This basically eats its way through the list, taking XORs along the way.",
   "translatedText": "এটি মূলত তালিকার মাধ্যমে তার পথ খায়, পথ ধরে XORs গ্রহণ করে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -560,7 +560,7 @@
   "end": 582.68
  },
  {
-  "input": "ition of an error. Let's say you detect an error among the odd columns, and among the right half. It necessarily means the error is somewhere in th ",
+  "input": "If you prefer, you can explicitly write out that XOR function without having to import it from anywhere.",
   "translatedText": "আপনি যদি চান, আপনি স্পষ্টভাবে XOR ফাংশনটি কোথাও থেকে আমদানি না করেই লিখতে পারেন।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -568,7 +568,7 @@
   "end": 589.44
  },
  {
-  "input": "So at the moment it looks like if we do this on our random block of 16 bits, it returns 9, which has the binary representation 1001. ",
+  "input": "So at the moment it looks like if we do this on our random block of 16 bits, it returns 9, which has the binary representation 1001.",
   "translatedText": "তাই এই মুহুর্তে এটা মনে হচ্ছে যদি আমরা আমাদের 16 বিটের এলোমেলো ব্লকে এটি করি, এটি 9 প্রদান করে, যার বাইনারি উপস্থাপনা 1001 আছে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0. ",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "আমরা এখানে এটি করব না, তবে আপনি একটি ফাংশন লিখতে পারেন যেখানে প্রেরক সেই বাইনারি উপস্থাপনা ব্যবহার করে প্রয়োজন অনুসারে চারটি প্যারিটি বিট সেট করে, শেষ পর্যন্ত এই ব্লকটিকে এমন একটি অবস্থায় নিয়ে আসে যেখানে বিটগুলির সম্পূর্ণ তালিকায় কোডের এই লাইনটি চালু হয়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -584,7 +584,7 @@
   "end": 615.46
  },
  {
-  "input": "This would be considered a well-prepared block. ",
+  "input": "This would be considered a well-prepared block.",
   "translatedText": "একটি 0 এটি একটি ভালভাবে প্রস্তুত ব্লক হিসাবে বিবেচিত হবে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. ",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "কি চমৎকার যে আমরা যদি এই তালিকার যেকোনো একটি বিট টগল করি, গোলমাল থেকে একটি এলোমেলো ত্রুটি অনুকরণ করে, তারপর যদি আপনি কোডের এই একই লাইনটি চালান, এটি সেই ত্রুটিটি প্রিন্ট করে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -600,7 +600,7 @@
   "end": 630.22
  },
  {
-  "input": "an error that changes a 1 to a 0. You see, if you add a bit string together twice, it's the same as ",
+  "input": "Isn't that neat?",
   "translatedText": "ঝরঝরে তাই না? ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any. ",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "আপনি নীল থেকে এই ব্লকটি পেতে পারেন, এটিতে এই একক লাইনটি চালান, এবং এটি স্বয়ংক্রিয়ভাবে একটি ত্রুটির অবস্থান বা 0 না থাকলে থুতু দেবে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -616,7 +616,7 @@
   "end": 641.06
  },
  {
-  "input": "And that effect, again, is that the total result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me sh ",
+  "input": "And there's nothing special about the size 16 here.",
   "translatedText": "এবং এখানে 16 আকার সম্পর্কে বিশেষ কিছু নেই।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -624,7 +624,7 @@
   "end": 645.2
  },
  {
-  "input": "The same line of code would work if you had a list of, say, 256 bits. ",
+  "input": "The same line of code would work if you had a list of, say, 256 bits.",
   "translatedText": "কোডের একই লাইন কাজ করবে যদি আপনার কাছে 256 বিটের একটি তালিকা থাকে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -632,7 +632,7 @@
   "end": 649.86
  },
  {
-  "input": "ferenced before, which will capture almost all of the logic on the receiver's end. We'll start by creating a random array of 16 ones and zeros to simulate the data block, and I'll go ahead and give it the name bits, but of course in practice this would be something that we're receiving f ",
+  "input": "Needless to say, there is more code to write here, like doing the meta parity check to detect 2-bit errors, but the idea is that almost all of the core logic from our scheme comes down to a single XOR reduction.",
   "translatedText": "বলা বাহুল্য, এখানে লেখার জন্য আরও কোড আছে, যেমন 2-বিট ত্রুটি সনাক্ত করতে মেটা প্যারিটি চেক করা, কিন্তু ধারণাটি হল যে আমাদের স্কিম থেকে প্রায় সমস্ত মূল যুক্তি একটি একক XOR হ্রাসে নেমে আসে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. ",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "এখন, বাইনারি এবং XORs এবং সাধারণভাবে সফ্টওয়্যারগুলির সাথে আপনার স্বাচ্ছন্দ্যের উপর নির্ভর করে, আপনি হয় এই দৃষ্টিকোণটিকে কিছুটা বিভ্রান্তিকর মনে করতে পারেন, বা এত বেশি মার্জিত এবং সহজ যে আপনি ভাবছেন কেন আমরা এটি থেকে শুরু করিনি।-যাওয়া. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level. ",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "ঢিলেঢালাভাবে বলতে গেলে, হার্ডওয়্যারে হ্যামিং কোডগুলিকে সরাসরি প্রয়োগ করার সময় মাল্টিপল প্যারিটি চেক দৃষ্টিকোণটি সম্পর্কে চিন্তা করা সহজ, এবং XOR দৃষ্টিকোণটি সফ্টওয়্যারে করার সময় চিন্তা করা সবচেয়ে সহজ, উচ্চ স্তরের ধরণের থেকে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -656,7 +656,7 @@
   "end": 690.5
  },
  {
-  "input": "l out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on. In this case it looks like those positions are 0, 4, 6, 9, etc. Remember, what ",
+  "input": "The first one is easiest to actually do by hand, and I think it does a better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the log of the size of the block, or in other words, it grows one bit at a time as the block size doubles.",
   "translatedText": "প্রথমটি আসলে হাত দ্বারা করা সবচেয়ে সহজ, এবং আমি মনে করি এটি এই সমস্তটির অন্তর্নিহিত মূল অন্তর্জ্ঞান স্থাপনের জন্য একটি ভাল কাজ করে, যা হল যে একটি একক ত্রুটি সনাক্ত করার জন্য প্রয়োজনীয় তথ্য ব্লকের আকারের লগের সাথে সম্পর্কিত।, বা অন্য কথায়, ব্লকের আকার দ্বিগুণ হওয়ার সাথে সাথে এটি এক সময়ে এক বিট বৃদ্ধি পায়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "we want is to collect together all of those positions, the positions of the bits that are turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. ",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "এখানে প্রাসঙ্গিক সত্য হল যে তথ্যটি সরাসরি আমাদের কতটা অপ্রয়োজনীয়তার প্রয়োজন তার সাথে মিলে যায়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -672,7 +672,7 @@
   "end": 716.06
  },
  {
-  "input": "That's really what runs against most people's knee-jerk reaction when they first think about making a message resilient to errors, where usually copying the whole message is the first instinct that comes to mind. ",
+  "input": "That's really what runs against most people's knee-jerk reaction when they first think about making a message resilient to errors, where usually copying the whole message is the first instinct that comes to mind.",
   "translatedText": "এটি আসলেই বেশিরভাগ লোকের হাঁটু-ঝাঁকুনির প্রতিক্রিয়ার বিরুদ্ধে চলে যখন তারা প্রথমে একটি বার্তাকে ত্রুটির প্রতি স্থিতিস্থাপক করার বিষয়ে চিন্তা করে, যেখানে সাধারণত পুরো বার্তাটি অনুলিপি করা প্রথম প্রবৃত্তি যা মনে আসে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix. ",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "এবং তারপরে, যাইহোক, এই সম্পূর্ণ অন্য উপায়ে আপনি মাঝে মাঝে হ্যামিং কোডগুলি উপস্থাপিত দেখতে পান, যেখানে আপনি একটি বড় ম্যাট্রিক্স দ্বারা বার্তাকে গুণ করেন।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -688,7 +688,7 @@
   "end": 734.0
  },
  {
-  "input": "It's kind of nice because it relates it to the broader family of linear codes, but I think that gives almost no intuition for where it comes from or how it scales. ",
+  "input": "It's kind of nice because it relates it to the broader family of linear codes, but I think that gives almost no intuition for where it comes from or how it scales.",
   "translatedText": "এটি একধরনের চমৎকার কারণ এটি রৈখিক কোডের বিস্তৃত পরিবারের সাথে সম্পর্কিত, তবে আমি মনে করি এটি কোথা থেকে আসে বা এটি কীভাবে স্কেল করে সে সম্পর্কে প্রায় কোনও অন্তর্দৃষ্টি দেয় না।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. ",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "এবং স্কেলিং এর কথা বলতে গেলে, আপনি লক্ষ্য করতে পারেন যে এই স্কিমের কার্যকারিতা কেবলমাত্র আমরা ব্লকের আকার বৃদ্ধি করার সাথে সাথে আরও ভাল হয়ে যায়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "looks like if we do this on our random block of 16 bits, it returns 9, which has the binary representation 1001. We won't do it here, but you could write a function wh ",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "উদাহরণস্বরূপ, আমরা দেখেছি যে 256 বিটের সাথে, আপনি অপ্রয়োজনীয়তার জন্য সেই স্থানের মাত্র 3% ব্যবহার করছেন এবং এটি সেখান থেকে আরও ভাল হতে থাকে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ere the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a state where running th ",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "একের পর এক প্যারিটি বিটের সংখ্যা বাড়ার সাথে সাথে ব্লকের আকার দ্বিগুণ হতে থাকে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits. ",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "এবং যদি আপনি এটিকে চরম পর্যায়ে নিয়ে যান, আপনার কাছে এক মিলিয়ন বিট সহ একটি ব্লক থাকতে পারে, যেখানে আপনি আক্ষরিক অর্থে আপনার প্যারিটি চেকের সাথে 20টি প্রশ্ন খেলতে পারবেন এবং এটি শুধুমাত্র 21টি প্যারিটি বিট ব্যবহার করে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -728,7 +728,7 @@
   "end": 780.02
  },
  {
-  "input": "And if you step back to think about looking at a million bits and locating a single error, that genuinely feels crazy. ",
+  "input": "And if you step back to think about looking at a million bits and locating a single error, that genuinely feels crazy.",
   "translatedText": "এবং যদি আপনি এক মিলিয়ন বিট দেখার এবং একটি একক ত্রুটি সনাক্ত করার বিষয়ে চিন্তা করার জন্য ফিরে যান, তবে এটি সত্যিকারের পাগল বোধ করে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that. ",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "সমস্যাটি, অবশ্যই, একটি বড় ব্লকের সাথে, এক বা দুটি বিটের বেশি ত্রুটি দেখার সম্ভাবনা বেড়ে যায় এবং হ্যামিং কোডগুলি এর বাইরে কিছু পরিচালনা করে না।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -744,7 +744,7 @@
   "end": 797.66
  },
  {
-  "input": "So in practice, what you'd want is to find the right size so that the probability of too many bit flips isn't too high. ",
+  "input": "So in practice, what you'd want is to find the right size so that the probability of too many bit flips isn't too high.",
   "translatedText": "তাই অনুশীলনে, আপনি যা চান তা হল সঠিক আকার খুঁজে বের করা যাতে অনেকগুলি বিট ফ্লিপ হওয়ার সম্ভাবনা খুব বেশি না হয়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -752,7 +752,7 @@
   "end": 804.3
  },
  {
-  "input": "imulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the positio ",
+  "input": "Also, in practice, errors tend to come in little bursts, which would totally ruin a single block, so one common tactic to help spread out a burst of errors across many different blocks is to interlace those blocks, like this, before they're sent out or stored.",
   "translatedText": "এছাড়াও, অভ্যাসগতভাবে, ত্রুটিগুলি সামান্য বিস্ফোরণে আসে, যা একটি একক ব্লককে সম্পূর্ণরূপে ধ্বংস করে দেয়, তাই বিভিন্ন ব্লক জুড়ে ত্রুটিগুলি ছড়িয়ে দিতে সাহায্য করার জন্য একটি সাধারণ কৌশল হল ব্লকগুলিকে এইভাবে ইন্টারলেস করা, সেগুলি হওয়ার আগে পাঠানো বা সঞ্চিত।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -760,7 +760,7 @@
   "end": 820.98
  },
  {
-  "input": "Then again, a lot of this is rendered completely moot by more modern codes, like the much more commonly used Reed-Solomon algorithm, which handles burst errors particularly well, and it can be tuned to be resilient to a larger number of errors per block. ",
+  "input": "Then again, a lot of this is rendered completely moot by more modern codes, like the much more commonly used Reed-Solomon algorithm, which handles burst errors particularly well, and it can be tuned to be resilient to a larger number of errors per block.",
   "translatedText": "তারপরে আবার, এর অনেক কিছুকে আরও আধুনিক কোড দ্বারা সম্পূর্ণরূপে রেন্ডার করা হয়েছে, যেমন অনেক বেশি ব্যবহৃত রিড-সলোমন অ্যালগরিদম, যা বিস্ফোরিত ত্রুটিগুলি বিশেষভাবে ভালভাবে পরিচালনা করে এবং প্রতি ব্লকে আরও বেশি সংখ্যক ত্রুটির প্রতি স্থিতিস্থাপক হতে এটি টিউন করা যেতে পারে।. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "But that's a topic for another time. ",
+  "input": "But that's a topic for another time.",
   "translatedText": "কিন্তু এটা অন্য সময়ের জন্য একটি বিষয়. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was. ",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "তার দ্য আর্ট অফ ডুয়িং সায়েন্স অ্যান্ড ইঞ্জিনিয়ারিং বইয়ে, হ্যামিং এই কোডের তার আবিষ্কারটি কতটা অস্থির ছিল সে সম্পর্কে বিস্ময়করভাবে স্পষ্ট।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -784,7 +784,7 @@
   "end": 849.94
  },
  {
-  "input": "He first tried all sorts of different schemes involving organizing the bits into parts of a higher dimensional lattice and strange things like this. ",
+  "input": "He first tried all sorts of different schemes involving organizing the bits into parts of a higher dimensional lattice and strange things like this.",
   "translatedText": "তিনি প্রথমে একটি উচ্চমাত্রিক জালির অংশে বিটগুলিকে সংগঠিত করার সাথে জড়িত বিভিন্ন ধরণের স্কিম এবং এর মতো অদ্ভুত জিনিসগুলি চেষ্টা করেছিলেন।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -792,7 +792,7 @@
   "end": 857.78
  },
  {
-  "input": "The idea that it might be possible to get parity checks to conspire in a way that spells out the position of an error only came to Hamming when he stepped back after a bunch of other analysis and asked, okay, what is the most efficient I could conceivably be about this? ",
+  "input": "The idea that it might be possible to get parity checks to conspire in a way that spells out the position of an error only came to Hamming when he stepped back after a bunch of other analysis and asked, okay, what is the most efficient I could conceivably be about this?",
   "translatedText": "এই ধারণা যে প্যারিটি চেকগুলি এমনভাবে ষড়যন্ত্র করার জন্য সম্ভব হতে পারে যা একটি ত্রুটির অবস্থানকে বানান করে তখনই হ্যামিংয়ের কাছে এসেছিল যখন তিনি একগুচ্ছ অন্যান্য বিশ্লেষণের পরে পিছিয়ে পড়েছিলেন এবং জিজ্ঞাসা করেছিলেন, ঠিক আছে, আমি সবচেয়ে দক্ষ কোনটি করতে পারি? সম্ভবত এই সম্পর্কে হতে পারে? ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -800,7 +800,7 @@
   "end": 871.52
  },
  {
-  "input": "He was also candid about how important it was that parity checks were already on his mind, which would have been way less common back in the 1940s than it is today. ",
+  "input": "He was also candid about how important it was that parity checks were already on his mind, which would have been way less common back in the 1940s than it is today.",
   "translatedText": "প্যারিটি চেকগুলি ইতিমধ্যেই তাঁর মাথায় ছিল কতটা গুরুত্বপূর্ণ সে সম্পর্কেও তিনি স্পষ্টবাদী ছিলেন, যা আজকের তুলনায় 1940 এর দশকে কম সাধারণ ছিল।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "is perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it ",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "এই বই জুড়ে প্রায় অর্ধ ডজন বার তিনি লুই পাস্তুরের উদ্ধৃতি উল্লেখ করেছেন, ভাগ্য একটি প্রস্তুত মনকে সমর্থন করে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -816,7 +816,7 @@
   "end": 888.22
  },
  {
-  "input": "Clever ideas often look deceptively simple in hindsight, which makes them easy to underappreciate. ",
+  "input": "Clever ideas often look deceptively simple in hindsight, which makes them easy to underappreciate.",
   "translatedText": "চতুর ধারণাগুলি প্রায়শই পশ্চাৎদৃষ্টিতে প্রতারণামূলকভাবে সহজ দেখায়, যা তাদের কম মূল্যায়ন করা সহজ করে তোলে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -824,7 +824,7 @@
   "end": 894.3
  },
  {
-  "input": "Right now my honest hope is that Hamming codes, or at least the possibility of such codes, feels almost obvious to you. ",
+  "input": "Right now my honest hope is that Hamming codes, or at least the possibility of such codes, feels almost obvious to you.",
   "translatedText": "এই মুহুর্তে আমার সৎ আশা হল হ্যামিং কোড, বা অন্তত এই ধরনের কোডগুলির সম্ভাবনা, আপনার কাছে প্রায় সুস্পষ্ট মনে হয়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't. ",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "কিন্তু আপনি নিজেকে বোকা বানানো উচিত নয় যে তারা আসলে সুস্পষ্ট, কারণ তারা অবশ্যই নয়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -840,7 +840,7 @@
   "end": 906.82
  },
  {
-  "input": ", with four yes or no questions, we have 16 possible outcomes for our parity checks, and at first that feels perfect for pinpointing 1 out of 16 positions in the block, but you also need to communicate a 17th outcome, the no error condition. The first one is easiest to actually do by hand, and I think it does a better job instilling the core intuition underlying all of this, ",
+  "input": "Part of the reason that clever ideas look deceptively easy is that we only ever see the final result, cleaning up what was messy, never mentioning all of the wrong turns, underselling just how vast the space of explorable possibilities is at the start of a problem solving process, all of that.",
   "translatedText": "চতুর ধারণাগুলিকে প্রতারণামূলকভাবে সহজ দেখায় তার একটি কারণ হল যে আমরা কেবল চূড়ান্ত ফলাফলটি দেখতে পাই, যা অগোছালো ছিল তা পরিষ্কার করে, সমস্ত ভুল বাঁকগুলির কথা কখনও উল্লেখ করি না, একটি সমস্যার শুরুতে অন্বেষণযোগ্য সম্ভাবনার জায়গাটি কতটা বিস্তৃত তা আন্ডারসেলিং করি।সমাধান প্রক্রিয়া, যে সব. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -848,7 +848,7 @@
   "end": 922.86
  },
  {
-  "input": "which is that the information required to locate a single error is relat ",
+  "input": "But this is true in general.",
   "translatedText": "কিন্তু এটি সাধারণভাবে সত্য।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -856,7 +856,7 @@
   "end": 924.9
  },
  {
-  "input": "ed to the log of the size of the block, or in other words, it grows one bit at a time as the block size doubles. The relevant fact here i ",
+  "input": "I think for some special inventions, there's a second, deeper reason that we underappreciate them.",
   "translatedText": "আমি মনে করি কিছু বিশেষ উদ্ভাবনের জন্য, একটি দ্বিতীয়, গভীর কারণ রয়েছে যে আমরা তাদের কম মূল্যায়ন করি।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -864,7 +864,7 @@
   "end": 930.04
  },
  {
-  "input": "Thinking of information in terms of bits had only really coalesced into a full theory by 1948, with Claude Shannon's seminal paper on information theory. ",
+  "input": "Thinking of information in terms of bits had only really coalesced into a full theory by 1948, with Claude Shannon's seminal paper on information theory.",
   "translatedText": "তথ্য তত্ত্বের উপর ক্লদ শ্যাননের সেমিনাল পেপারের সাথে 1948 সালের মধ্যে বিটগুলির পরিপ্রেক্ষিতে তথ্যের চিন্তা সত্যিই একটি সম্পূর্ণ তত্ত্বে একত্রিত হয়েছিল।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -872,7 +872,7 @@
   "end": 938.64
  },
  {
-  "input": "block is even, just like a normal parity check. Now, if there's a single bit error, then ",
+  "input": "This was essentially concurrent with when Hamming developed his algorithm.",
   "translatedText": "হ্যামিং যখন তার অ্যালগরিদম তৈরি করেছিলেন তখন এটি মূলত একই সাথে ছিল।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "the parity of the full block toggles to be odd, but we would catch that anyway thanks to the four error-correcting checks. However, if there's two errors, then the overall parity is going to toggle back to be And then, by the way, there is this whole other way that you s ",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "এটি একই ভিত্তিগত কাগজ যা দেখিয়েছিল, একটি নির্দিষ্ট অর্থে, যে দক্ষ ত্রুটি সংশোধন সর্বদা সম্ভব, বিট ফ্লিপ হওয়ার সম্ভাবনা যতই উচ্চ হোক না কেন, অন্তত তত্ত্বে।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -888,7 +888,7 @@
   "end": 952.9
  },
  {
-  "input": "Shannon and Hamming, by the way, shared an office in Bell Labs, despite working on very different things, which hardly seems coincidental here. ",
+  "input": "Shannon and Hamming, by the way, shared an office in Bell Labs, despite working on very different things, which hardly seems coincidental here.",
   "translatedText": "শ্যানন এবং হ্যামিং, যাইহোক, বেল ল্যাবসে একটি অফিস ভাগ করেছেন, খুব ভিন্ন জিনিস নিয়ে কাজ করা সত্ত্বেও, যা এখানে খুব কমই কাকতালীয় বলে মনে হয়।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "multiply the message by one big matrix. It's kind of nice because it relates it to the broader family of linear codes, but I think that gives almost no intuition for where it comes from or how it scales. ",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "বেশ কয়েক দশক ধরে দ্রুত এগিয়ে যাওয়া, এবং এই দিনগুলিতে, আমাদের মধ্যে অনেকেই বিট এবং তথ্য সম্পর্কে এতটাই নিমগ্ন যে চিন্তার এই পদ্ধতিটি কতটা স্বতন্ত্র ছিল তা উপেক্ষা করা সহজ।",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -904,7 +904,7 @@
   "end": 972.34
  },
  {
-  "input": "Ironically, the ideas that most profoundly shape the ways that a future generation thinks will end up looking to that future generation simpler than they really are. ",
+  "input": "Ironically, the ideas that most profoundly shape the ways that a future generation thinks will end up looking to that future generation simpler than they really are.",
   "translatedText": "হাস্যকরভাবে, যে ধারণাগুলি ভবিষ্যত প্রজন্মের চিন্তাভাবনাগুলিকে সবচেয়ে গভীরভাবে আকার দেয় সেগুলি ভবিষ্যত প্রজন্মের কাছে সত্যিকারের চেয়ে সহজতর হবে।",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/chinese/sentence_translations.json b/2020/hamming-codes-2/chinese/sentence_translations.json
index ed512d5fd..952c28878 100644
--- a/2020/hamming-codes-2/chinese/sentence_translations.json
+++ b/2020/hamming-codes-2/chinese/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "我们讨论的是汉明码，这是一种创建数据块的方法 ，其中大多数位携带有意义的消息，而其他一些 位则充当一种冗余，这样如果任何位被翻转，要么 是一条消息位或冗余位，该块中的任何内容，接 收器将能够识别出存在错误，以及如何修复它。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "那里提出的基本思想是如何使用多个奇 偶校验来进行二进制搜索以找出错误。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "例如，二进制中的数字 7 看起来像 011 1，本质上是说它是 4 加 2 加 1。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "请注意位置 7 所在的位置，它确实影响我们的第一 个奇偶组，以及第二个和第三个，但不影响最后一个。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "因此，从下到上读取这四次检查的 结果确实可以阐明错误的位置。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "当我们将这些二进制标签放回它们的盒子时 ，让我强调它们与实际发送的数据不同。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "它们只不过是一个概念标签，可以 帮助你我理解四个奇偶组的来源。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "用二进制描述我们所看到的一切的优雅可能会因为我 们所看到的一切都以二进制描述的混乱而被削弱。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "我们得到的是四个奇偶校验组中的第一个，这意 味着您可以将第一个检查解释为询问，嘿，如果 有错误，该错误位置的最后一位是否为 1？",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "等等。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "第一个是如何系统地推广到大于 2 的幂的块大小。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "这意味着这些奇偶校验位中的每一个都位 于四个奇偶校验组中的一个且仅一个内。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "当您对两位进行异或时，如果其中一位打开，它将返回 1，但如果两者都打开或关闭，则不会返回 1。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "换句话说，它是这两个位的奇偶校验。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "这就像加法，但你永远不会携带。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "对你和我来说，关键点在于，对许多不同的位 串进行异或运算实际上是一种计算一堆单独 组的模仿的方法，就像列一样，一举完成。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "这为我们提供了一种相当时髦的方式来思考汉明码算法中 的多个奇偶校验，因为所有这些都被打包到一个操作中。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "那有意义吗？",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "同样，下一列计算第二个奇偶校验组中有 多少个位置、倒数第二个位为 1 的位 置以及也突出显示的位置，依此类推。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "现在，一旦我们有了这样的结果，这给了我们一个非常好的方 法来思考为什么底部的这四个结果位直接拼出错误的位置。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "假设此块中的某些位从 0 切换到 1。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "这意味着该位的位置现在将包含在总 XOR 中，这会将总和从 0 更改 为这个新包含的值，即错误的位置。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "我们将首先创建一个由 16 个 1 和 0 组成的随 机数组来模拟数据块，我将给它命名位，但当然，在实践 中，这将是我们从发送方接收的内容，而不是如果是随机 的，它将携带 11 个数据位和 5 个奇偶校验位。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "因此，如果我们创建一个列表，循环遍历所有这些对，看起来像 i 的对，然后我们只取出 i 值，只取出索引，好吧，这并 不是那么令人兴奋，我们只是取回那些索引 0 到 15。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "但是，如果我们添加条件以仅执行此 if 位，即如果该位 是 1 而不是 0，那么它只会提取相应位打开的位置。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "我们不会在这里这样做，但您可以编写一个函数，其中发送方 使用该二进制表示形式根据需要设置四个奇偶校验位，最终 使该块达到在完整位列表上运行这行代码的状态一个 0。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "很酷的是，如果我们切换此列表中的任何一位，模拟噪声引起的 随机错误，那么如果您运行同一行代码，它就会打印出该错误。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "你可以突然得到这个块，在上面运行这一行，它会 自动吐出错误的位置，如果没有错误则吐出 0。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "现在，根据您对二进制、异或和软件的熟悉程度，您可能 会发现这种观点有点令人困惑，或者更加优雅和简单，以 至于您想知道为什么我们不从一开始就开始使用它-去。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "宽松地说，当非常直接地在硬件中实现汉明码时，更 容易考虑多重奇偶校验的观点，而当在软件中从更高 的层次上实现汉明码时，最容易考虑异或的观点。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "这里的相关事实是，该信息直 接对应于我们需要多少冗余。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "然后，顺便说一句，有时您会看到汉明码的另 一种呈现方式，即您将消息乘以一个大矩阵。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "说到扩展，您可能会注意到，当我们增加 块大小时，该方案的效率只会变得更好。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "例如，我们看到，对于 256 位，您仅使用该空间 的 3% 进行冗余，并且从那里开始变得越来越好。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "随着奇偶校验位的数量逐个增加，块大小不断加倍。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "如果你把它发挥到极致，你可能会拥有一个具有 1 00 万位的块，实际上你会用奇偶校验来回答 2 0 个问题，而它只使用 21 个奇偶校验位。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "当然，问题在于，对于较大的块，看到超过一或两个位错误 的概率会上升，而汉明码无法处理超出此范围的任何内容。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "但这是另一个话题了。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "汉明在他的《科学与工程的艺术》一书中非常坦 诚地讲述了他发现这段代码的过程是多么曲折。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "在这本书中，他大约有六次引用了路易斯· 巴斯德的名言：幸运眷顾有准备的头脑。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "但你不应该自欺欺人地认为它们实际上 是显而易见的，因为它们绝对不是。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "这篇基础论文在某种意义上表明，无 论位翻转的概率有多高，有效的纠错 总是可能的，至少在理论上是这样。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "快进几十年，如今，我们中的许多人都沉浸在对比特和 信息的思考中，很容易忽视这种思维方式的独特性。",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/french/sentence_translations.json b/2020/hamming-codes-2/french/sentence_translations.json
index 6593b4017..20c719ed0 100644
--- a/2020/hamming-codes-2/french/sentence_translations.json
+++ b/2020/hamming-codes-2/french/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "Nous parlions des codes de Hamming, une façon de créer un bloc de données dont la plupart des bits portent un message significatif, tandis que quelques autres agissent comme une sorte de redondance, de telle sorte que si un bit est inversé, soit un message bit ou un bit de redondance, n'importe quoi dans ce bloc, un récepteur sera capable d'identifier qu'il y a eu une erreur et comment la corriger.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "L'idée de base présentée ici était de savoir comment utiliser plusieurs contrôles de parité pour effectuer une recherche binaire jusqu'à l'erreur.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "Par exemple, le nombre 7 en binaire ressemble à 0111, ce qui signifie essentiellement que c'est 4 plus 2 plus 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "Et remarquez où se situe la position 7, elle affecte le premier de nos groupes paritaires, ainsi que le deuxième et le troisième, mais pas le dernier.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "Ainsi, la lecture des résultats de ces quatre contrôles de bas en haut précise bien la position de l’erreur.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "Alors que nous remettons ces étiquettes binaires dans leurs boîtes, permettez-moi de souligner qu'elles sont distinctes des données réellement envoyées.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "Ce n'est rien de plus qu'une étiquette conceptuelle pour nous aider, vous et moi, à comprendre d'où viennent les quatre groupes paritaires.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "L'élégance d'avoir tout ce que nous regardons soit décrit en binaire est peut-être sapée par la confusion d'avoir tout ce que nous regardons étant décrit en binaire.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "Ce que nous obtenons est le premier de nos quatre groupes de parité, ce qui signifie que vous pouvez interpréter cette première vérification comme demandant : hé, s’il y a une erreur, le dernier bit à la position de cette erreur est-il un 1?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "Et ainsi de suite.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "La première est de savoir comment généraliser systématiquement à des tailles de blocs qui sont des puissances de deux plus grandes.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "Cela signifie que chacun de ces bits de parité se trouve dans un et un seul des quatre groupes de parité.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "Lorsque vous effectuez le XOR de deux bits, il renvoie un 1 si l'un de ces bits est activé, mais pas si les deux sont activés ou désactivés.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "Exprimé différemment, c'est la parité de ces deux bits.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "C'est comme une addition, mais où l'on ne porte jamais.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "Le point clé pour vous et moi est que prendre le XOR de nombreuses chaînes de bits différentes est effectivement un moyen de calculer les parodies d'un groupe de groupes séparés, comme c'est le cas avec les colonnes, d'un seul coup.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "Cela nous donne une façon plutôt élégante de considérer les multiples contrôles de parité de notre algorithme de code de Hamming comme étant tous regroupés en une seule opération.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "Cela a-t-il du sens?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "De même, la colonne suivante compte le nombre de positions dans le deuxième groupe de parité, les positions dont l'avant-dernier bit est un 1 et qui sont également mises en surbrillance, et ainsi de suite.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "Maintenant, une fois que nous avons cela, cela nous donne une très bonne façon de réfléchir à la raison pour laquelle ces quatre bits résultants en bas indiquent directement la position d'une erreur.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "Disons qu'un élément de ce bloc passe de 0 à 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "Cela signifie que la position de ce bit va maintenant être incluse dans le XOR total, ce qui fait passer la somme de 0 à cette valeur nouvellement incluse, la position de l'erreur.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "Nous allons commencer par créer un tableau aléatoire de 16 1 et 0 pour simuler le bloc de données, et je lui donnerai le nom des bits, mais bien sûr, en pratique, ce serait quelque chose que nous recevons d'un expéditeur, et au lieu de étant aléatoire, il transporterait 11 bits de données ainsi que 5 bits de parité.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "Donc, si nous créons ensuite une liste qui boucle sur toutes ces paires, des paires qui ressemblent à i, et que nous extrayons ensuite uniquement la valeur i, juste l'index, eh bien, ce n'est pas si excitant, nous récupérons simplement ces indices de 0 à 15.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "Mais si nous ajoutons la condition de ne faire cela que si bit, c'est-à-dire si ce bit est un 1 et non un 0, alors il extrait uniquement les positions où le bit correspondant est activé.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "Nous ne le ferons pas ici, mais vous pouvez écrire une fonction dans laquelle l'expéditeur utilise cette représentation binaire pour définir les quatre bits de parité selon les besoins, amenant finalement ce bloc à un état où l'exécution de cette ligne de code sur la liste complète des bits renvoie un 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "Ce qui est cool, c'est que si nous basculons l'un des bits de cette liste, simulant une erreur aléatoire due au bruit, alors si vous exécutez cette même ligne de code, cette erreur est affichée.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "Vous pouvez obtenir ce bloc à l'improviste, exécuter cette seule ligne dessus, et il crachera automatiquement la position d'une erreur, ou un 0 s'il n'y en avait pas.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "Maintenant, selon votre aisance avec les binaires, les XOR et les logiciels en général, vous pouvez soit trouver cette perspective un peu déroutante, soit tellement plus élégante et simple que vous vous demandez pourquoi nous ne l'avons pas commencé dès le début. -aller.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "En gros, la perspective du contrôle de parité multiple est plus facile à penser lors de l'implémentation très directe des codes de Hamming dans le matériel, et la perspective XOR est la plus facile à penser lorsqu'on l'effectue dans le logiciel, à partir d'un niveau supérieur.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "Le fait pertinent ici est que ces informations correspondent directement au niveau de redondance dont nous avons besoin.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "Et puis, en passant, il y a cette toute autre façon de voir parfois les codes de Hamming présentés, où vous multipliez le message par une grande matrice.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "Et en parlant de mise à l'échelle, vous remarquerez peut-être que l'efficacité de ce système ne fait que s'améliorer à mesure que nous augmentons la taille des blocs.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "Par exemple, nous avons vu qu'avec 256 bits, vous n'utilisez que 3 % de cet espace pour la redondance, et la situation ne cesse de s'améliorer à partir de là.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "À mesure que le nombre de bits de parité augmente un par un, la taille du bloc continue de doubler.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "Et si vous poussez cela à l'extrême, vous pourriez avoir un bloc avec, disons, un million de bits, dans lequel vous joueriez littéralement 20 questions avec vos contrôles de parité, et il n'utiliserait que 21 bits de parité.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "Le problème, bien sûr, est qu’avec un bloc plus grand, la probabilité de voir plus d’un ou deux bits d’erreur augmente, et les codes de Hamming ne gèrent rien d’autre au-delà.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "Mais c'est un sujet pour une autre fois.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "Dans son livre The Art of Doing Science and Engineering, Hamming est merveilleusement franc sur les méandres de sa découverte de ce code.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "Il y a environ une demi-douzaine de fois tout au long de ce livre où il fait référence à la citation de Louis Pasteur, la chance favorise un esprit préparé.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "Mais vous ne devriez pas vous tromper en pensant qu’ils sont en réalité évidents, car ils ne le sont certainement pas.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "Il s’agissait du même article fondateur qui montrait, dans un certain sens, qu’une correction d’erreur efficace est toujours possible, quelle que soit la probabilité de retournements de bits, du moins en théorie.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "Avance rapide de plusieurs décennies, et de nos jours, beaucoup d’entre nous sont tellement plongés dans la réflexion sur des éléments et des informations qu’il est facile d’oublier à quel point cette façon de penser était distincte.",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/german/sentence_translations.json b/2020/hamming-codes-2/german/sentence_translations.json
index a38c3d561..6526b5211 100644
--- a/2020/hamming-codes-2/german/sentence_translations.json
+++ b/2020/hamming-codes-2/german/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "Wir sprachen über Hamming-Codes, eine Möglichkeit, einen Datenblock zu erstellen, bei dem die meisten Bits eine sinnvolle Nachricht enthalten, während einige andere als eine Art Redundanz fungieren, so dass, wenn ein Bit umgedreht wird, entweder eine Nachricht entsteht Ob ein Bit oder ein Redundanzbit, irgendetwas in diesem Block, ein Empfänger kann erkennen, dass ein Fehler aufgetreten ist und wie er ihn beheben kann.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "Die dort vorgestellte Grundidee bestand darin, mithilfe mehrerer Paritätsprüfungen binär bis zum Fehler zu suchen.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "Beispielsweise sieht die Zahl 7 im Binärformat wie 0111 aus, was im Wesentlichen bedeutet, dass sie 4 plus 2 plus 1 ist.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "Und beachten Sie, wo sich die Position 7 befindet. Sie betrifft zwar die erste unserer Paritätsgruppen und die zweite und die dritte, aber nicht die letzte.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "Wenn man also die Ergebnisse dieser vier Prüfungen von unten nach oben liest, lässt sich tatsächlich die Position des Fehlers erkennen.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "Während wir diese binären Etiketten wieder in ihre Boxen stecken, möchte ich betonen, dass sie sich von den Daten unterscheiden, die tatsächlich gesendet werden.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "Sie sind nichts weiter als eine konzeptionelle Bezeichnung, die Ihnen und mir helfen soll, zu verstehen, woher die vier Paritätsgruppen stammen.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "Die Eleganz, alles, was wir betrachten, binär zu beschreiben, wird möglicherweise durch die Verwirrung untergraben, die entsteht, wenn alles, was wir betrachten, binär beschrieben wird.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "Was wir bekommen, ist die erste unserer vier Paritätsgruppen, was bedeutet, dass Sie diese erste Prüfung so interpretieren können, dass Sie fragen: „Hey, wenn es einen Fehler gibt, ist das letzte Bit an der Position dieses Fehlers eine 1?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "“ Und so weiter.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "Die erste besteht darin, wie man systematisch auf Blockgrößen verallgemeinert, die größere Zweierpotenzen sind.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "Das bedeutet, dass jedes dieser Paritätsbits innerhalb einer und nur einer der vier Paritätsgruppen liegt.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "Wenn Sie die XOR-Verknüpfung zweier Bits verwenden, wird eine 1 zurückgegeben, wenn eines dieser Bits aktiviert ist, nicht jedoch, wenn beide aktiviert oder deaktiviert sind.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "Anders ausgedrückt ist es die Parität dieser beiden Bits.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "Es ist wie eine Ergänzung, die man aber nie trägt.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "Der entscheidende Punkt für Sie und mich ist, dass die XOR-Verknüpfung vieler verschiedener Bitfolgen effektiv eine Möglichkeit ist, die Parodien einer Reihe separater Gruppen, wie etwa bei den Spalten, auf einen Schlag zu berechnen.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "Dies gibt uns eine ziemlich schicke Möglichkeit, uns vorzustellen, dass die mehreren Paritätsprüfungen unseres Hamming-Code-Algorithmus alle in einer einzigen Operation zusammengefasst sind.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "Ist das sinnvoll?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "Ebenso zählt die nächste Spalte, wie viele Positionen sich in der zweiten Paritätsgruppe befinden, die Positionen, deren vorletztes Bit eine 1 ist und die ebenfalls hervorgehoben sind, und so weiter.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "Wenn wir es nun so haben, können wir wirklich gut darüber nachdenken, warum diese vier resultierenden Bits unten direkt die Position eines Fehlers angeben.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "Nehmen wir an, ein Bit in diesem Block wird von 0 auf 1 umgeschaltet.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "Das bedeutet, dass die Position dieses Bits nun in die gesamte XOR-Verknüpfung einbezogen wird, wodurch sich die Summe von 0 in diesen neu einbezogenen Wert, die Position des Fehlers, ändert.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "Wir beginnen damit, ein zufälliges Array aus 16 Einsen und Nullen zu erstellen, um den Datenblock zu simulieren, und ich gebe ihm den Namen Bits, aber in der Praxis würden wir das natürlich von einem Absender erhalten, und statt dessen Da es zufällig ist, würde es 11 Datenbits zusammen mit 5 Paritätsbits übertragen.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "Wenn wir dann also eine Liste erstellen, die alle diese Paare durchläuft, Paare, die wie i aussehen, und dann nur den i-Wert, nur den Index, herausziehen, ist das nicht so aufregend, wir bekommen einfach die Indizes 0 bis 15 zurück.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "Aber wenn wir die Bedingung hinzufügen, dies nur zu tun, wenn das Bit eine 1 und keine 0 ist, dann werden nur die Positionen herausgezogen, an denen das entsprechende Bit aktiviert ist.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "Wir werden es hier nicht tun, aber Sie könnten eine Funktion schreiben, bei der der Absender diese binäre Darstellung verwendet, um die vier Paritätsbits nach Bedarf zu setzen und diesen Block letztendlich in einen Zustand zu bringen, in dem die Ausführung dieser Codezeile auf der vollständigen Liste der Bits zurückkehrt eine 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "Das Coole ist, dass, wenn wir eines der Bits in dieser Liste umschalten und so einen zufälligen Fehler durch Rauschen simulieren, dieser Fehler ausgegeben wird, wenn Sie dieselbe Codezeile ausführen.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "Sie könnten diesen Block aus heiterem Himmel bekommen, diese einzelne Zeile darauf ausführen und er würde automatisch die Position eines Fehlers ausspucken, oder eine 0, wenn es keinen gab.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "Nun, je nachdem, wie gut Sie mit Binär- und XOR-Funktionen und Software im Allgemeinen vertraut sind, finden Sie diese Perspektive möglicherweise etwas verwirrend oder so viel eleganter und einfacher, dass Sie sich fragen, warum wir nicht gleich von Anfang an damit begonnen haben -gehen.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "Vereinfacht gesagt lässt sich die Perspektive der Mehrfachparitätsprüfung leichter in Betracht ziehen, wenn man Hamming-Codes direkt in Hardware implementiert, und die XOR-Perspektive lässt sich am einfachsten in Betracht ziehen, wenn man sie in Software von einer höheren Ebene aus durchführt.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "Die relevante Tatsache hierbei ist, dass diese Informationen direkt mit der benötigten Redundanz korrespondieren.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "Und dann gibt es übrigens noch eine ganz andere Art und Weise, wie man manchmal Hamming-Codes präsentiert, bei denen man die Nachricht mit einer großen Matrix multipliziert.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "Apropos Skalierung: Sie werden vielleicht feststellen, dass die Effizienz dieses Schemas nur dann besser wird, wenn wir die Blockgröße erhöhen.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "Wir haben beispielsweise gesehen, dass Sie bei 256 Bit nur 3 % dieses Speicherplatzes für Redundanz nutzen, und von da an wird es immer besser.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "Wenn die Anzahl der Paritätsbits nach und nach zunimmt, verdoppelt sich die Blockgröße immer weiter.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "Und wenn Sie das auf die Spitze treiben, könnten Sie einen Block mit, sagen wir, einer Million Bits haben, in dem Sie mit Ihren Paritätsprüfungen im wahrsten Sinne des Wortes 20 Fragen abspielen würden, und der nur 21 Paritätsbits verwendet.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "Das Problem besteht natürlich darin, dass mit einem größeren Block die Wahrscheinlichkeit steigt, mehr als ein oder zwei Bitfehler zu sehen, und Hamming-Codes verarbeiten nichts darüber hinaus.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "Aber das ist ein Thema für ein anderes Mal.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "In seinem Buch „The Art of Doing Science and Engineering“ spricht Hamming wunderbar offen darüber, wie kompliziert seine Entdeckung dieses Codes war.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "In diesem Buch verweist er ungefähr ein halbes Dutzend Mal auf das Zitat von Louis Pasteur: „Glück begünstigt einen vorbereiteten Geist.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "Aber Sie sollten sich nicht der Illusion hingeben, dass sie tatsächlich offensichtlich sind, denn das ist definitiv nicht der Fall.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "Dabei handelte es sich um dieselbe Grundlagenarbeit, die in gewisser Weise zeigte, dass eine effiziente Fehlerkorrektur immer möglich ist, unabhängig davon, wie hoch die Wahrscheinlichkeit von Bit-Flips ist, zumindest theoretisch.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "Mehrere Jahrzehnte später sind viele von uns so sehr in das Nachdenken über Bits und Informationen vertieft, dass man leicht übersieht, wie unterschiedlich diese Denkweise war.",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/hebrew/sentence_translations.json b/2020/hamming-codes-2/hebrew/sentence_translations.json
index 94099b980..cddda9d5a 100644
--- a/2020/hamming-codes-2/hebrew/sentence_translations.json
+++ b/2020/hamming-codes-2/hebrew/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "דיברנו על קודי Hamming, דרך ליצור גוש נתונים שבו רוב הביטים נושאים מסר משמעותי, בעוד שכמה אחרים פועלים כסוג של יתירות, באופן כזה שאם ביט כלשהו יתהפך, או הודעה סיביות או סיביות יתירות, כל דבר בבלוק הזה, מקלט יוכל לזהות שהייתה שגיאה ואיך לתקן אותה.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "הרעיון הבסיסי שהוצג שם היה כיצד להשתמש בבדיקות זוגיות מרובות כדי לחפש בינארי בדרך למטה אל השגיאה.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "לדוגמה, המספר 7 בבינארי נראה כמו 0111, בעצם אומר שהוא 4 ועוד 2 ועוד 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "ושימו לב היכן יושבת עמדה 7, היא אכן משפיעה על הראשונה בקבוצות השוויוניות שלנו, והשנייה, והשלישית, אך לא האחרונה.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "אז קריאת התוצאות של ארבעת הבדיקות הללו מלמטה למעלה אכן מפרטת את מיקומו של השגיאה.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "כשאנחנו מחזירים את התוויות הבינאריות האלה לקופסאות שלהן, הרשו לי להדגיש שהן שונות מהנתונים שנשלחים בפועל.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "הם לא יותר מאשר תווית מושגית כדי לעזור לך ולי להבין מאיפה הגיעו ארבע קבוצות השוויון.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "האלגנטיות של זה שכל מה שאנחנו מסתכלים עליו יתואר בבינארי הוא אולי תחת הבלבול של זה שכל מה שאנחנו מסתכלים עליו מתואר בבינארי.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "מה שאנחנו מקבלים היא הראשונה מבין ארבע קבוצות השוויון שלנו, מה שאומר שאתה יכול לפרש את הסימון הראשון הזה כשואל, היי, אם יש שגיאה, האם הביט האחרון במיקום השגיאה הוא 1?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "וכולי.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "הראשון הוא איך להכליל באופן שיטתי לגדלי בלוקים שהם עצמות גדולות יותר של שניים.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "המשמעות היא שכל אחד מאותם סיביות זוגיות יושב בתוך אחת ויחידה מארבע קבוצות הזוגיות.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "כאשר אתה לוקח את ה-XOR של שני סיביות, זה יחזיר 1 אם אחד מהסיביות האלה מופעל, אבל לא אם שניהם מופעלים או כבויים.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "בניסוח שונה, זה השוויון של שני הביטים האלה.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "זה כמו תוספת, אבל איפה שאתה אף פעם לא נושא.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "נקודת המפתח עבורך ולי היא שלקיחת ה-XOR של מחרוזות סיביות שונות היא למעשה דרך לחשב את הפרודיות של חבורה של קבוצות נפרדות, כמו כך עם העמודות, הכל במכה אחת.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "זה נותן לנו דרך די מטופשת לחשוב על בדיקות השוויון המרובות מאלגוריתם קוד Hamming שלנו, כשהם ארוזים יחד לפעולה אחת.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "האם זה הגיוני?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "כמו כן, העמודה הבאה סופרת כמה עמדות יש בקבוצת השוויון השנייה, המיקומים שהביט השני אחרון שלהם הוא 1, ואשר גם הם מודגשים, וכן הלאה.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "עכשיו ברגע שיש לנו את זה ככה, זה נותן לנו דרך ממש נחמדה לחשוב מדוע ארבעת הביטים המתקבלים האלה בתחתית מאייתים ישירות את המיקום של שגיאה.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "נניח שחלק מהגוש הזה עובר מ-0 ל-1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "מה שזה אומר הוא שהמיקום של הביט הזה ייכלל כעת ב-XOR הכולל, מה שמשנה את הסכום מ-0 לערך זה החדש שנכלל, מיקום השגיאה.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "נתחיל ביצירת מערך אקראי של 16 1 ו-0 כדי לדמות את בלוק הנתונים, ואני אתן לו את סיביות השם, אבל כמובן שבפועל זה יהיה משהו שאנחנו מקבלים מהשולח, ובמקום בהיותו אקראי הוא יוביל 11 סיביות נתונים יחד עם 5 סיביות זוגיות.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "אז אם אנחנו יוצרים רשימה שמסתובבת בלולאה על כל הזוגות האלה, זוגות שנראים כמו i, ואז נוציא רק את ערך i, רק את המדד, ובכן, זה לא כל כך מרגש, אנחנו פשוט מקבלים בחזרה את המדדים האלה 0 עד 15.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "אבל אם נוסיף את התנאי לעשות את זה רק אם ביט, כלומר אם הביט הזה הוא 1 ולא 0, ובכן, אז הוא שולף רק את המיקומים שבהם הביט המקביל מופעל.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "לא נעשה את זה כאן, אבל אתה יכול לכתוב פונקציה שבה השולח משתמש בייצוג הבינארי הזה כדי להגדיר את ארבעת סיביות הזוגיות לפי הצורך, ובסופו של דבר להביא את הבלוק הזה למצב שבו הפעלת שורת קוד זו ברשימת הביטים המלאה מחזירה א 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "מה שמגניב הוא שאם נחליף כל אחד מהסיביות ברשימה הזו, המדמה שגיאה אקראית מרעש, אז אם אתה מפעיל את אותה שורת קוד, הוא מדפיס את השגיאה הזו.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "אתה יכול לקבל את הבלוק הזה ישר, להריץ עליו את השורה הבודדת הזו, והוא ינוק אוטומטית את המיקום של שגיאה, או 0 אם לא הייתה כזו.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "כעת, בהתאם לנוחות שלך עם רכיבי בינארי ו-XOR ותוכנה באופן כללי, ייתכן שתמצא את הפרספקטיבה הזו קצת מבלבלת, או הרבה יותר אלגנטי ופשוט שאתה תוהה למה לא התחלנו איתה מההתחלה -ללכת.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "באופן רופף, קל יותר לחשוב על פרספקטיבה של בדיקת זוגיות מרובה בעת יישום קודי Hamming בחומרה באופן ישיר מאוד, ואת פרספקטיבה של XOR קל יותר לחשוב עליה כאשר עושים זאת בתוכנה, מרמה גבוהה יותר.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "העובדה הרלוונטית כאן היא שהמידע הזה מתאים ישירות לכמות היתירות שאנחנו צריכים.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "ואז, אגב, יש את כל הדרך האחרת הזו שלפעמים רואים את קודי האמינג מוצגים, שבה אתה מכפיל את המסר במטריצה אחת גדולה.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "ואם כבר מדברים על קנה מידה, אולי תשים לב שהיעילות של תכנית זו רק משתפרת ככל שאנו מגדילים את גודל הבלוק.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "לדוגמה, ראינו שעם 256 סיביות, אתה משתמש רק ב-3% מהשטח הזה עבור יתירות, ומשם זה רק הולך ומשתפר.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "ככל שמספר סיביות הזוגיות גדל בזה אחר זה, גודל הבלוק ממשיך להכפיל את עצמו.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "ואם אתה לוקח את זה לקיצוניות, אתה יכול לקבל בלוק עם, נגיד, מיליון ביטים, שבו אתה ממש משחק 20 שאלות עם בדיקות השוויון שלך, והוא משתמש רק ב-21 ביטים זוגיות.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "הבעיה, כמובן, היא שעם בלוק גדול יותר, ההסתברות לראות יותר משגיאת סיביות אחת או שתיים עולה, וקודי Hamming לא מטפלים בשום דבר מעבר לזה.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "אבל זה נושא לפעם אחרת.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "בספרו The Art of Doing Science and Engineering, האמינג הוא כנה להפליא לגבי מידת הפיתול של גילוי הקוד הזה.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "יש כמו חצי תריסר פעמים במהלך הספר הזה שהוא מתייחס לציטוט של לואי פסטר, המזל מעדיף מוח מוכן.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "אבל אתה לא צריך להטעות את עצמך לחשוב שהם בעצם ברורים, כי הם בהחלט לא.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "זה היה אותו מאמר יסוד שהראה, במובן מסוים, שתיקון שגיאות יעיל תמיד אפשרי, לא משנה כמה גבוהה ההסתברות להיפוך סיביות, לפחות בתיאוריה.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "הרץ קדימה כמה עשורים, ובימים אלה, רבים מאיתנו שקועים כל כך בחשיבה על פיסות ומידע שקל להתעלם עד כמה הייתה צורת החשיבה הזו מובחנת.",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/hindi/sentence_translations.json b/2020/hamming-codes-2/hindi/sentence_translations.json
index f11faa861..38dffc2f0 100644
--- a/2020/hamming-codes-2/hindi/sentence_translations.json
+++ b/2020/hamming-codes-2/hindi/sentence_translations.json
@@ -7,14 +7,14 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "हम हैमिंग कोड के बारे में बात कर रहे थे, डेटा का एक ब्लॉक बनाने का एक तरीका जहां अधिकांश बिट्स एक सार्थक संदेश ले जाते हैं, जबकि कुछ अन्य एक प्रकार की अतिरेक के रूप में कार्य करते हैं, इस तरह से कि यदि कोई बिट फ़्लिप हो जाता है, तो या तो एक संदेश बिट या अतिरेक बिट, इस ब्लॉक में कुछ भी, रिसीवर यह पहचानने में सक्षम होगा कि कोई त्रुटि थी, और इसे कैसे ठीक किया जाए।",
   "n_reviews": 0,
   "start": 3.06,
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "वहां प्रस्तुत मूल विचार यह था कि त्रुटि तक पहुंचने के लिए बाइनरी खोज के लिए एकाधिक समता जांच का उपयोग कैसे किया जाए।",
   "n_reviews": 0,
   "start": 21.88,
@@ -49,21 +49,21 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "उदाहरण के लिए, बाइनरी में संख्या 7 0111 की तरह दिखती है, अनिवार्य रूप से यह कहती है कि यह 4 प्लस 2 प्लस 1 है।",
   "n_reviews": 0,
   "start": 64.78,
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "और ध्यान दें कि स्थिति 7 कहाँ बैठती है, यह हमारे समता समूहों में से पहले, और दूसरे, और तीसरे को प्रभावित करती है, लेकिन अंतिम को नहीं।",
   "n_reviews": 0,
   "start": 72.54,
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "इसलिए नीचे से ऊपर तक उन चार जांचों के परिणामों को पढ़ने से वास्तव में त्रुटि की स्थिति का पता चल जाता है।",
   "n_reviews": 0,
   "start": 82.22,
@@ -84,21 +84,21 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "जैसे ही हम इन बाइनरी लेबलों को उनके बक्सों में वापस डालते हैं, मैं इस बात पर जोर देना चाहता हूं कि वे वास्तव में भेजे जा रहे डेटा से अलग हैं।",
   "n_reviews": 0,
   "start": 110.56,
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "वे आपको और मुझे यह समझने में मदद करने के लिए एक वैचारिक लेबल से ज्यादा कुछ नहीं हैं कि चार समता समूह कहां से आए।",
   "n_reviews": 0,
   "start": 118.32,
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "हम जो कुछ भी देख रहे हैं उसे बाइनरी में वर्णित करने की सुंदरता शायद इस भ्रम के कारण कम हो गई है कि हम जो कुछ भी देख रहे हैं उसका वर्णन बाइनरी में किया जा रहा है।",
   "n_reviews": 0,
   "start": 124.14,
@@ -119,7 +119,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "हमें जो मिलता है वह हमारे चार समता समूहों में से पहला है, जिसका अर्थ है कि आप उस पहले चेक की व्याख्या यह पूछ सकते हैं कि, अरे, यदि कोई त्रुटि है, तो क्या उस त्रुटि की स्थिति में अंतिम बिट 1 है?",
   "n_reviews": 0,
   "start": 144.24,
@@ -140,7 +140,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "और इसी तरह।",
   "n_reviews": 0,
   "start": 175.76,
@@ -168,7 +168,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "पहला यह है कि उन आकारों को ब्लॉक करने के लिए व्यवस्थित रूप से सामान्यीकरण कैसे किया जाए जो दो की बड़ी घात हैं।",
   "n_reviews": 0,
   "start": 202.04,
@@ -210,7 +210,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "इसका मतलब यह है कि उनमें से प्रत्येक समता बिट चार समता समूहों में से एक और केवल एक के अंदर बैठता है।",
   "n_reviews": 0,
   "start": 243.6,
@@ -245,14 +245,14 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "जब आप दो बिट्स का एक्सओआर लेते हैं, तो यदि इनमें से कोई एक बिट चालू है तो यह 1 लौटाएगा, लेकिन यदि दोनों चालू या बंद हैं तो नहीं।",
   "n_reviews": 0,
   "start": 290.78,
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "अलग-अलग शब्दों में, यह इन दो बिट्स की समता है।",
   "n_reviews": 0,
   "start": 300.1,
@@ -273,7 +273,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "यह जोड़ की तरह है, लेकिन जहां आप कभी नहीं ले जाते।",
   "n_reviews": 0,
   "start": 313.68,
@@ -294,14 +294,14 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "आपके और मेरे लिए मुख्य बिंदु यह है कि कई अलग-अलग बिट स्ट्रिंग्स का एक्सओआर लेना प्रभावी रूप से अलग-अलग समूहों के समूह की पैरोडी की गणना करने का एक तरीका है, जैसे कि कॉलम के साथ, सभी एक ही झटके में।",
   "n_reviews": 0,
   "start": 334.96,
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "यह हमें हमारे हैमिंग कोड एल्गोरिदम से कई समता जांचों के बारे में सोचने का एक आसान तरीका देता है क्योंकि सभी को एक ही ऑपरेशन में एक साथ पैक किया जाता है।",
   "n_reviews": 0,
   "start": 351.26,
@@ -336,14 +336,14 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "समझ आया?",
   "n_reviews": 0,
   "start": 406.24,
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "इसी तरह, अगला कॉलम गिनता है कि दूसरे समता समूह में कितनी स्थितियाँ हैं, वे स्थितियाँ जिनका दूसरा से अंतिम बिट 1 है, और जिन्हें हाइलाइट भी किया गया है, इत्यादि।",
   "n_reviews": 0,
   "start": 409.08,
@@ -371,21 +371,21 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "अब एक बार जब हमारे पास यह इस तरह हो जाता है, तो यह हमें यह सोचने का एक बहुत अच्छा तरीका देता है कि नीचे ये चार परिणामी बिट्स सीधे त्रुटि की स्थिति क्यों बताते हैं।",
   "n_reviews": 0,
   "start": 439.04,
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "मान लीजिए कि इस ब्लॉक में कुछ बिट 0 से 1 पर टॉगल हो जाता है।",
   "n_reviews": 0,
   "start": 448.46,
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "इसका मतलब यह है कि उस बिट की स्थिति अब कुल XOR में शामिल होने जा रही है, जो योग को 0 से बदलकर इस नए शामिल मूल्य, त्रुटि की स्थिति में बदल देती है।",
   "n_reviews": 0,
   "start": 452.6,
@@ -427,7 +427,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "हम डेटा ब्लॉक को अनुकरण करने के लिए 16 1s और 0s की एक यादृच्छिक सरणी बनाकर शुरू करेंगे, और मैं इसे बिट्स नाम दूंगा, लेकिन व्यवहार में यह कुछ ऐसा होगा जो हम एक प्रेषक से प्राप्त कर रहे हैं, और इसके बजाय यादृच्छिक होने के कारण इसमें 5 समता बिट्स के साथ 11 डेटा बिट्स होंगे।",
   "n_reviews": 0,
   "start": 502.08,
@@ -441,14 +441,14 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "इसलिए यदि हम एक सूची बनाते हैं जो इन सभी जोड़ियों पर लूप करती है, जो जोड़े जो i की तरह दिखते हैं, और फिर हम केवल i मान, केवल सूचकांक निकालते हैं, खैर यह उतना रोमांचक नहीं है, हम बस उन सूचकांकों को 0 से 15 तक वापस लाते हैं .",
   "n_reviews": 0,
   "start": 528.18,
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "लेकिन अगर हम केवल बिट होने पर ऐसा करने की शर्त जोड़ते हैं, जिसका अर्थ है कि यदि वह बिट 1 है और 0 नहीं है, तो यह केवल उन स्थितियों को बाहर निकालता है जहां संबंधित बिट चालू है।",
   "n_reviews": 0,
   "start": 541.68,
@@ -504,7 +504,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "हम इसे यहां नहीं करेंगे, लेकिन आप एक फ़ंक्शन लिख सकते हैं जहां प्रेषक आवश्यकतानुसार चार समता बिट्स सेट करने के लिए उस बाइनरी प्रतिनिधित्व का उपयोग करता है, अंततः इस ब्लॉक को उस स्थिति में ले जाता है जहां बिट्स की पूरी सूची पर कोड की इस पंक्ति को चलाने पर रिटर्न मिलता है एक 0.",
   "n_reviews": 0,
   "start": 601.98,
@@ -518,7 +518,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "अच्छी बात यह है कि यदि हम शोर से यादृच्छिक त्रुटि का अनुकरण करते हुए इस सूची में से किसी एक बिट को टॉगल करते हैं, तो यदि आप कोड की इसी पंक्ति को चलाते हैं, तो यह उस त्रुटि को प्रिंट करता है।",
   "n_reviews": 0,
   "start": 619.88,
@@ -532,7 +532,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "आप इस ब्लॉक को अचानक से प्राप्त कर सकते हैं, इस पर इस एकल पंक्ति को चला सकते हैं, और यह स्वचालित रूप से किसी त्रुटि की स्थिति या यदि कोई त्रुटि नहीं है तो 0 बता देगा।",
   "n_reviews": 0,
   "start": 631.82,
@@ -560,14 +560,14 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "अब, सामान्य रूप से बाइनरी और एक्सओआर और सॉफ़्टवेयर के साथ आपकी सुविधा के आधार पर, आपको या तो यह परिप्रेक्ष्य थोड़ा भ्रमित करने वाला लग सकता है, या इतना अधिक सुरुचिपूर्ण और सरल कि आप सोच रहे होंगे कि हमने शुरुआत से ही इसकी शुरुआत क्यों नहीं की -जाना।",
   "n_reviews": 0,
   "start": 666.12,
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "संक्षेप में कहें तो, हार्डवेयर में हैमिंग कोड को बहुत सीधे लागू करते समय मल्टीपल पैरिटी चेक परिप्रेक्ष्य के बारे में सोचना आसान होता है, और सॉफ़्टवेयर में इसे उच्च स्तर से करते समय XOR परिप्रेक्ष्य के बारे में सोचना सबसे आसान होता है।",
   "n_reviews": 0,
   "start": 679.14,
@@ -581,7 +581,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "यहां प्रासंगिक तथ्य यह है कि वह जानकारी सीधे तौर पर इस बात से मेल खाती है कि हमें कितनी अतिरेक की आवश्यकता है।",
   "n_reviews": 0,
   "start": 711.02,
@@ -595,7 +595,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "और फिर, वैसे, यह एक और तरीका है जिसमें आप कभी-कभी हैमिंग कोड प्रस्तुत करते हुए देखते हैं, जहां आप संदेश को एक बड़े मैट्रिक्स से गुणा करते हैं।",
   "n_reviews": 0,
   "start": 727.5,
@@ -609,28 +609,28 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "और स्केलिंग की बात करते हुए, आप देख सकते हैं कि जैसे-जैसे हम ब्लॉक आकार बढ़ाते हैं, इस योजना की दक्षता बेहतर होती जाती है।",
   "n_reviews": 0,
   "start": 745.2,
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "उदाहरण के लिए, हमने देखा कि 256 बिट्स के साथ, आप उस स्थान का केवल 3% अतिरेक के लिए उपयोग कर रहे हैं, और यह वहां से बेहतर होता जा रहा है।",
   "n_reviews": 0,
   "start": 755.0,
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "जैसे-जैसे समता बिट्स की संख्या एक-एक करके बढ़ती जाती है, ब्लॉक का आकार दोगुना होता जाता है।",
   "n_reviews": 0,
   "start": 763.3,
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "और यदि आप इसे चरम सीमा तक ले जाते हैं, तो आपके पास एक मिलियन बिट्स वाला एक ब्लॉक हो सकता है, जहां आप वस्तुतः अपने समता जांच के साथ 20 प्रश्न खेल रहे होंगे, और यह केवल 21 समता बिट्स का उपयोग करता है।",
   "n_reviews": 0,
   "start": 769.0,
@@ -644,7 +644,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "निस्संदेह, समस्या यह है कि बड़े ब्लॉक के साथ, एक या दो से अधिक बिट त्रुटियाँ देखने की संभावना बढ़ जाती है, और हैमिंग कोड इससे आगे कुछ भी संभाल नहीं पाते हैं।",
   "n_reviews": 0,
   "start": 788.2,
@@ -672,14 +672,14 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "लेकिन यह अगली बार का विषय है।",
   "n_reviews": 0,
   "start": 839.36,
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "अपनी पुस्तक द आर्ट ऑफ डूइंग साइंस एंड इंजीनियरिंग में, हैमिंग ने आश्चर्यजनक रूप से स्पष्ट रूप से बताया है कि इस कोड की उनकी खोज कितनी टेढ़ी-मेढ़ी थी।",
   "n_reviews": 0,
   "start": 842.5,
@@ -707,7 +707,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "इस पुस्तक में लगभग आधा दर्जन बार उन्होंने लुई पाश्चर के इस कथन का संदर्भ दिया है कि भाग्य तैयार दिमाग का साथ देता है।",
   "n_reviews": 0,
   "start": 881.92,
@@ -728,7 +728,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "लेकिन आपको यह सोचकर खुद को मूर्ख नहीं बनाना चाहिए कि वे वास्तव में स्पष्ट हैं, क्योंकि वे निश्चित रूप से नहीं हैं।",
   "n_reviews": 0,
   "start": 901.66,
@@ -770,7 +770,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "यह वही मूलभूत पेपर था जिसने एक निश्चित अर्थ में दिखाया कि कुशल त्रुटि सुधार हमेशा संभव है, चाहे बिट फ़्लिप की संभावना कितनी भी अधिक क्यों न हो, कम से कम सिद्धांत में।",
   "n_reviews": 0,
   "start": 943.3,
@@ -784,7 +784,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "कई दशक तेजी से आगे बढ़े, और इन दिनों, हममें से कई लोग छोटी-छोटी बातों और सूचनाओं के बारे में सोचने में इतने डूबे हुए हैं कि इस बात को नजरअंदाज करना आसान है कि सोचने का यह तरीका कितना अलग था।",
   "n_reviews": 0,
   "start": 962.38,
diff --git a/2020/hamming-codes-2/hungarian/sentence_translations.json b/2020/hamming-codes-2/hungarian/sentence_translations.json
index acf0fc301..f29199859 100644
--- a/2020/hamming-codes-2/hungarian/sentence_translations.json
+++ b/2020/hamming-codes-2/hungarian/sentence_translations.json
@@ -336,7 +336,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "Olyan mint az összeadás, csak nincs tovább vitt érték.",
   "model": "DeepL",
   "n_reviews": 1,
@@ -416,7 +416,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "Hasonlóképpen, a következő oszlop azt számolja, hogy hány olyan pozíció van a második paritáscsoportban, amelyek utolsó előtti bitje 1, emellett szintén kiemeltek. És így tovább.",
   "model": "DeepL",
   "n_reviews": 1,
@@ -943,4 +943,4 @@
   "start": 973.1,
   "end": 982.26
  }
-]
+]
\ No newline at end of file
diff --git a/2020/hamming-codes-2/indonesian/sentence_translations.json b/2020/hamming-codes-2/indonesian/sentence_translations.json
index 1d25f1576..6cc63c747 100644
--- a/2020/hamming-codes-2/indonesian/sentence_translations.json
+++ b/2020/hamming-codes-2/indonesian/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "Kita berbicara tentang kode Hamming, suatu cara untuk membuat blok data yang sebagian besar bitnya membawa pesan yang bermakna, sementara beberapa bit lainnya bertindak sebagai semacam redundansi, sedemikian rupa sehingga jika ada bit yang dibalik, maka akan muncul pesan. bit atau bit redundansi, apa pun di blok ini, penerima akan dapat mengidentifikasi kesalahan yang terjadi, dan cara memperbaikinya.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "Ide dasar yang disajikan di sana adalah bagaimana menggunakan beberapa pemeriksaan paritas untuk mencari biner hingga menemukan kesalahan.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "Misalnya, angka 7 dalam biner terlihat seperti 0111, yang pada dasarnya berarti 4 ditambah 2 ditambah 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "Dan perhatikan di mana posisi 7 berada, itu memang mempengaruhi kelompok paritas pertama kita, dan kelompok paritas kedua, dan ketiga, tapi bukan yang terakhir.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "Jadi membaca hasil keempat pemeriksaan tersebut dari bawah ke atas memang menunjukkan posisi kesalahannya.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "Saat kita mengembalikan label biner ini ke dalam kotaknya, izinkan saya menekankan bahwa label tersebut berbeda dari data yang sebenarnya dikirim.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "Itu tidak lebih dari sebuah label konseptual untuk membantu Anda dan saya memahami dari mana empat kelompok paritas itu berasal.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "Keanggunan dalam mendeskripsikan segala sesuatu yang kita lihat dalam biner mungkin dilemahkan oleh kebingungan karena segala sesuatu yang kita lihat dijelaskan dalam biner.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "Apa yang kita dapatkan adalah yang pertama dari empat kelompok paritas, yang berarti Anda dapat menafsirkan pemeriksaan pertama itu sebagai pertanyaan, hei, jika ada kesalahan, apakah bit terakhir pada posisi kesalahan itu adalah 1?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "Dan seterusnya.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "Yang pertama adalah bagaimana menggeneralisasi secara sistematis ke ukuran blok yang merupakan pangkat dua yang lebih besar.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "Artinya, masing-masing bit paritas tersebut berada di dalam satu dan hanya satu dari empat grup paritas.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "Saat Anda mengambil XOR dari dua bit, itu akan mengembalikan 1 jika salah satu dari bit tersebut diaktifkan, tetapi tidak jika keduanya diaktifkan atau dinonaktifkan.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "Dengan kata lain, ini adalah paritas dari dua bit ini.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "Ini seperti tambahan, tetapi Anda tidak pernah membawanya.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "Poin kuncinya bagi Anda dan saya adalah bahwa mengambil XOR dari banyak string bit yang berbeda secara efektif merupakan cara untuk menghitung parodi dari sekelompok grup terpisah, seperti halnya dengan kolom, semuanya dalam satu gerakan.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "Ini memberi kita cara yang agak menarik untuk memikirkan tentang beberapa pemeriksaan paritas dari algoritma kode Hamming karena semuanya dikemas bersama menjadi satu operasi tunggal.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "Apakah itu masuk akal?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "Demikian pula, kolom berikutnya menghitung berapa banyak posisi dalam grup paritas kedua, posisi yang bit kedua hingga terakhirnya adalah 1, dan yang juga disorot, dan seterusnya.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "Sekarang setelah kita memilikinya seperti ini, ini memberi kita cara yang sangat bagus untuk memikirkan mengapa keempat bit yang dihasilkan di bawah ini secara langsung menguraikan posisi kesalahan.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "Katakanlah beberapa bit di blok ini diubah dari 0 menjadi 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "Artinya adalah posisi bit tersebut sekarang akan dimasukkan dalam total XOR, yang mengubah jumlah dari 0 menjadi nilai yang baru dimasukkan, posisi kesalahan.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "Kita akan mulai dengan membuat array acak 16 1 dan 0 untuk mensimulasikan blok data, dan saya akan memberinya nama bit, tapi tentu saja dalam praktiknya ini akan menjadi sesuatu yang kita terima dari pengirim, dan bukannya karena acak, ia akan membawa 11 bit data bersama dengan 5 bit paritas.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "Jadi jika kita kemudian membuat daftar yang mengulang semua pasangan ini, pasangan yang terlihat seperti i, dan kemudian kita hanya mengeluarkan nilai i, hanya indeksnya, itu tidak terlalu menarik, kita hanya mendapatkan kembali indeks tersebut 0 sampai 15.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "Tetapi jika kita menambahkan kondisi untuk hanya melakukan ini jika bit, yang berarti jika bit tersebut adalah 1 dan bukan 0, maka bit tersebut hanya akan menarik keluar posisi di mana bit terkait diaktifkan.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "Kami tidak akan melakukannya di sini, tetapi Anda dapat menulis fungsi di mana pengirim menggunakan representasi biner tersebut untuk mengatur empat bit paritas sesuai kebutuhan, yang pada akhirnya membuat blok ini ke keadaan di mana menjalankan baris kode ini pada daftar bit lengkap akan kembali sebuah 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "Yang keren adalah jika kita mengganti salah satu bit dalam daftar ini, menyimulasikan kesalahan acak dari noise, lalu jika Anda menjalankan baris kode yang sama, kesalahan tersebut akan dicetak.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "Anda bisa mendapatkan blok ini secara tiba-tiba, menjalankan satu baris ini di atasnya, dan secara otomatis akan memunculkan posisi kesalahan, atau 0 jika tidak ada.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "Sekarang, tergantung pada kenyamanan Anda dengan biner dan XOR serta perangkat lunak secara umum, Anda mungkin menganggap perspektif ini sedikit membingungkan, atau jauh lebih elegan dan sederhana sehingga Anda bertanya-tanya mengapa kami tidak memulainya dari awal. -pergi.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "Secara longgar, perspektif pemeriksaan paritas berganda lebih mudah untuk dipikirkan ketika mengimplementasikan kode Hamming pada perangkat keras secara langsung, dan perspektif XOR paling mudah untuk dipikirkan ketika melakukannya dalam perangkat lunak, dari tingkat yang lebih tinggi.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "Fakta yang relevan di sini adalah bahwa informasi tersebut secara langsung berhubungan dengan seberapa banyak redundansi yang kita butuhkan.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "Lalu, ada cara lain yang terkadang Anda lihat menampilkan kode Hamming, yaitu mengalikan pesan dengan satu matriks besar.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "Dan berbicara tentang penskalaan, Anda mungkin memperhatikan bahwa efisiensi skema ini semakin baik seiring dengan peningkatan ukuran blok.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "Misalnya, kita melihat bahwa dengan 256 bit, Anda hanya menggunakan 3% dari ruang tersebut untuk redundansi, dan hal tersebut terus menjadi lebih baik dari sana.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "Ketika jumlah bit paritas bertambah satu per satu, ukuran blok terus berlipat ganda.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "Dan jika Anda menganggapnya ekstrem, Anda bisa memiliki blok dengan, katakanlah, satu juta bit, di mana Anda benar-benar akan memainkan 20 pertanyaan dengan pemeriksaan paritas Anda, dan blok tersebut hanya menggunakan 21 bit paritas.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "Masalahnya, tentu saja, dengan blok yang lebih besar, kemungkinan melihat lebih dari satu atau dua kesalahan bit akan meningkat, dan kode Hamming tidak dapat menangani apa pun selain itu.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "Tapi itu topik untuk lain waktu.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "Dalam bukunya The Art of Doing Science and Engineering, Hamming sangat berterus terang tentang betapa berliku-liku penemuan kode ini.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "Ada setengah lusin kali dalam buku ini dia merujuk pada kutipan Louis Pasteur, keberuntungan berpihak pada pikiran yang siap.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "Namun Anda tidak boleh membodohi diri sendiri dengan berpikir bahwa hal tersebut sebenarnya sudah jelas, karena sebenarnya tidak.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "Ini adalah makalah dasar yang sama yang menunjukkan, dalam arti tertentu, bahwa koreksi kesalahan yang efisien selalu mungkin dilakukan, tidak peduli seberapa tinggi kemungkinan pembalikan bit, setidaknya secara teori.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "Beberapa dekade kemudian, dan saat ini, banyak dari kita yang begitu tenggelam dalam pemikiran tentang hal-hal kecil dan informasi sehingga mudah untuk mengabaikan betapa berbedanya cara berpikir ini.",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/italian/sentence_translations.json b/2020/hamming-codes-2/italian/sentence_translations.json
index f9e46dd52..cb9b0b582 100644
--- a/2020/hamming-codes-2/italian/sentence_translations.json
+++ b/2020/hamming-codes-2/italian/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "Stavamo parlando dei codici di Hamming, un modo per creare un blocco di dati in cui la maggior parte dei bit porta un messaggio significativo, mentre alcuni altri agiscono come una sorta di ridondanza, in modo tale che se qualche bit viene invertito, o un messaggio bit o un bit di ridondanza, qualsiasi cosa in questo blocco, un ricevitore sarà in grado di identificare che si è verificato un errore e come risolverlo.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "L'idea di base presentata era come utilizzare più controlli di parità per eseguire la ricerca binaria fino all'errore.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "Ad esempio, il numero 7 in binario assomiglia a 0111, il che significa essenzialmente che è 4 più 2 più 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "E notate dove si trova la posizione 7, influenza il primo dei nostri gruppi di parità, il secondo e il terzo, ma non l'ultimo.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "Quindi leggere i risultati di questi quattro controlli dal basso verso l’alto effettivamente spiega la posizione dell’errore.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "Mentre rimettiamo queste etichette binarie nelle loro scatole, lasciatemi sottolineare che sono distinte dai dati effettivamente inviati.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "Non sono altro che un'etichetta concettuale per aiutare te e me a capire da dove provengono i quattro gruppi di parità.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "L'eleganza di avere tutto ciò che stiamo guardando descritto in binario è forse indebolita dalla confusione di avere tutto ciò che stiamo guardando descritto in binario.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "Ciò che otteniamo è il primo dei nostri quattro gruppi di parità, il che significa che puoi interpretare il primo controllo come se chiedessi, ehi, se c'è un errore, l'ultimo bit nella posizione di quell'errore è 1?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "E così via.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "Il primo è come generalizzare sistematicamente alle dimensioni dei blocchi che sono potenze maggiori di due.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "Ciò significa che ciascuno di questi bit di parità si trova all'interno di uno e solo uno dei quattro gruppi di parità.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "Quando prendi lo XOR di due bit, restituirà 1 se uno di questi bit è attivato, ma non se entrambi sono attivati o disattivati.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "Detto diversamente, è la parità di questi due bit.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "È come un'addizione, ma dove non porti mai.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "Il punto chiave per te e me è che prendere lo XOR di molte stringhe di bit diverse è effettivamente un modo per calcolare le parodie di un gruppo di gruppi separati, come nel caso delle colonne, tutto in un colpo solo.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "Questo ci offre un modo piuttosto elegante di pensare ai controlli di parità multipli del nostro algoritmo di codice Hamming come se fossero tutti raggruppati insieme in un'unica operazione.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "Ha senso?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "Allo stesso modo, la colonna successiva conta quante posizioni ci sono nel secondo gruppo di parità, le posizioni il cui penultimo bit è 1 e che sono anch'esse evidenziate, e così via.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "Ora, una volta ottenuto questo risultato, questo ci dà un modo davvero carino di pensare al motivo per cui questi quattro bit risultanti in basso indicano direttamente la posizione di un errore.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "Diciamo che qualche bit in questo blocco viene commutato da 0 a 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "Ciò significa che la posizione di quel bit verrà ora inclusa nello XOR totale, che cambia la somma da 0 a questo nuovo valore incluso, la posizione dell'errore.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "Inizieremo creando un array casuale di 16 1 e 0 per simulare il blocco di dati, e gli darò i bit del nome, ma ovviamente in pratica questo sarebbe qualcosa che riceviamo da un mittente, e invece di essendo casuale trasporterebbe 11 bit di dati insieme a 5 bit di parità.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "Quindi, se poi creiamo un elenco che scorre su tutte queste coppie, coppie che assomigliano a i, e poi tiriamo fuori solo il valore i, solo l'indice, beh non è così eccitante, recuperiamo semplicemente quegli indici da 0 a 15.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "Ma se aggiungiamo la condizione di farlo solo se bit, ovvero se quel bit è un 1 e non uno 0, allora estrarrà solo le posizioni in cui il bit corrispondente è attivato.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "Non lo faremo qui, ma potresti scrivere una funzione in cui il mittente utilizza quella rappresentazione binaria per impostare i quattro bit di parità secondo necessità, portando infine questo blocco a uno stato in cui l'esecuzione di questa riga di codice sull'elenco completo dei bit restituisce uno 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "La cosa interessante è che se attiviamo uno qualsiasi dei bit in questo elenco, simulando un errore casuale dovuto al rumore, se esegui la stessa riga di codice, viene stampato quell'errore.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "Potresti prendere questo blocco all'improvviso, eseguire questa singola riga su di esso e sputerà automaticamente la posizione di un errore o uno 0 se non ce n'era.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "Ora, a seconda della tua dimestichezza con il binario, gli XOR e il software in generale, potresti trovare questa prospettiva un po' confusa, o molto più elegante e semplice da chiederti perché non l'abbiamo iniziata dall'inizio -andare.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "In parole povere, la prospettiva del controllo di parità multipla è più facile da pensare quando si implementano i codici Hamming nell'hardware in modo molto diretto, e la prospettiva XOR è più facile da pensare quando lo si fa nel software, da un livello più alto.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "Il fatto rilevante qui è che tali informazioni corrispondono direttamente alla quantità di ridondanza di cui abbiamo bisogno.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "E poi, a proposito, c'è tutto questo altro modo in cui a volte vedi presentati i codici Hamming, dove moltiplichi il messaggio per un'unica grande matrice.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "E parlando di ridimensionamento, potresti notare che l'efficienza di questo schema migliora solo quando aumentiamo la dimensione del blocco.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "Ad esempio, abbiamo visto che con 256 bit si utilizza solo il 3% di quello spazio per la ridondanza e da lì in poi le cose continuano a migliorare.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "Man mano che il numero di bit di parità cresce uno per uno, la dimensione del blocco continua a raddoppiare.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "E se lo porti all'estremo, potresti avere un blocco con, diciamo, un milione di bit, dove giocheresti letteralmente a 20 domande con i tuoi controlli di parità, e utilizza solo 21 bit di parità.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "Il problema, ovviamente, è che con un blocco più grande, la probabilità di vedere più di uno o due bit di errore aumenta, e i codici di Hamming non gestiscono nulla oltre a questo.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "Ma questo è un argomento per un'altra volta.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "Nel suo libro The Art of Doing Science and Engineering, Hamming è meravigliosamente sincero riguardo a quanto tortuosa sia stata la sua scoperta di questo codice.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "Ci sono circa una mezza dozzina di volte in questo libro in cui fa riferimento alla citazione di Louis Pasteur, la fortuna aiuta una mente preparata.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "Ma non dovresti illuderti pensando che in realtà siano ovvi, perché sicuramente non lo sono.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "Si trattava dello stesso documento fondamentale che mostrava, in un certo senso, che una correzione efficiente degli errori è sempre possibile, non importa quanto sia alta la probabilità di bit flip, almeno in teoria.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "Andiamo avanti velocemente di diversi decenni e, al giorno d'oggi, molti di noi sono così immersi nel pensare a frammenti e informazioni che è facile trascurare quanto fosse distinto questo modo di pensare.",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/japanese/sentence_translations.json b/2020/hamming-codes-2/japanese/sentence_translations.json
index 3e9709e8a..6fe5fc4e6 100644
--- a/2020/hamming-codes-2/japanese/sentence_translations.json
+++ b/2020/hamming-codes-2/japanese/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "私たちはハミング コードについて話していました。 これは、ほとんどのビットが意味のあ るメッセージを運ぶデータ ブロックを作成する方法であり、他のいくつかのビットは一種 の冗長性として機能し、ビットが反転した場合、メッセージが送信されるか、メッセージが 送信されるかが決まります。 ビットや冗長ビットなど、このブロック内のあらゆるものによ って、受信機はエラーがあったことと、それを修正する方法を識別できるようになります。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "そこで提示された基本的なアイデアは、複数のパリティ チェッ クを使用してエラーに至るまでバイナリ検索を行う方法でした。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "たとえば、2 進数の 7 は 0111 のように見え、本質的 には 4 プラス 2 プラス 1 であることを示しています。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "位置 7 がどこに位置するかに注目してください。 パリティ グループ の最初、2 番目、3 番目には影響しますが、最後には影響しません。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "したがって、これら 4 つのチェックの結果を下か ら上に読むと、エラーの位置が明らかになります。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "これらのバイナリ ラベルを箱に戻すときに、実際に送信 されるデータとは区別されることを強調しておきます。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "これらは、4 つのパリティ グループがどこから来たの かを理解するのに役立つ概念的なラベルにすぎません。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "私たちが見ているものすべてがバイナリで記述されることの優雅さは、おそらく、私たち が見ているものすべてがバイナリで記述されることの混乱によって損なわれるでしょう。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "得られるのは 4 つのパリティ グループの最初のグループです。 つ まり、最初のチェックは、エラーがある場合、そのエラーの位置にある 最後のビットは 1 ですか? という質問であると解釈できます。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "等々。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "1 つ目は、2 の累乗より大きいブロック サイズに体系的に一般化する方法です。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "これが意味するのは、これらのパリティ ビットはそれぞれ、4 つのパ リティ グループのうちの 1 つのみの中に存在するということです。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "2 つのビットの XOR を計算すると、それらのビットのいずれかがオンで あれば 1 が返されますが、両方がオンまたはオフの場合は返されません。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "別の言い方をすると、これはこれら 2 ビットのパリティです。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "それは足し算のようなものですが、決して持ち歩かない場所です。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "あなたと私にとって重要な点は、多くの異なるビット文字列の X OR をとることは、列の場合と同様に、多数の別々のグループの パロディを一度に計算する効果的な方法であるということです。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "これにより、ハミング コード アルゴリズムからの複数のパリティ チェックがすべて 1 つの操作にパッケージ化されていると考える、かなり気の利いた方法が得られます。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "それは理にかなっていますか？",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "同様に、次の列では、2 番目のパリティ グループに位 置がいくつあるか、最後から 2 番目のビットが 1 で、強調表示されている位置などがカウントされます。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "このようにすると、結果として得られる下部の 4 つのビットが エラーの位置を直接表す理由を考える非常に良い方法になります。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "このブロック内の一部のビットが 0 から 1 に切り替わるとします。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "これが意味するのは、そのビットの位置が合計 XOR に含 まれることになり、合計が 0 から、代わりにこの新しく含 まれた値、つまりエラーの位置に変更されるということです。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "まず、データ ブロックをシミュレートするために 16 個の 1 と 0 の ランダムな配列を作成し、それに bits という名前を付けますが、もちろ ん実際には、これは送信者から受信するものになります。 ランダムであるため、1 1 個のデータ ビットと 5 個のパリティ ビットを運ぶことになります。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "したがって、これらすべてのペア (i に似たペア) をループするリストを作 成し、i の値だけ、インデックスだけを取り出すとします。 それほど面白いこ とではありません。 インデックス 0 から 15 が返されるだけです。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "しかし、ビットの場合のみ、つまりそのビットが 0 ではなく 1 である場合にのみこれを実 行するという条件を追加すると、対応するビットがオンになっている位置のみが抽出されます。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "ここではそれを行いませんが、送信者がそのバイナリ表現を使用して必要に応じて 4 つのパリティ ビットを設定し、最終的にこのブロックをビットの完全なリストに対して このコード行を実行すると返される状態にする関数を作成することもできます。 0。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "素晴らしいのは、このリストのビットのいずれかを切り替えて、ノイズによるランダムなエ ラーをシミュレートし、同じコード行を実行すると、そのエラーが出力されることです。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "このブロックを突然取得し、その上でこの 1 行を実行すると、エラーの位 置が自動的に出力され、エラーが存在しない場合は 0 が出力されます。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "さて、バイナリ、XOR、およびソフトウェア全般に慣れているかどうかに応じて、こ の視点が少しわかりにくいと感じるか、またははるかにエレガントでシンプルなので、 なぜ最初からこの視点を始めなかったのかと不思議に思うかもしれません。 -行く。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "大まかに言うと、複数のパリティ チェックの観点は、ハミング コードを ハードウェアで直接実装する場合に考えやすく、XOR の観点は、ソフト ウェアで実行する場合に、より高いレベルから考えるのが最も簡単です。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "ここで重要な事実は、その情報が必要な冗長 性の量に直接対応しているということです。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "そして、ところで、時々ハミング コードが表示されるのを目にすることがあります が、これとはまったく別の方法で、メッセージに 1 つの大きな行列を掛けます。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "スケーリングについて言えば、ブロック サイズが増加するにつれ てこのスキームの効率が向上することに気づくかもしれません。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "たとえば、256 ビットでは、冗長性のためにそのスペースの 3% の みが使用されており、そこからさらに改善され続けることがわかりました。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "パリティ ビットの数が 1 つずつ増加すると、ブロック サイズは 2 倍になり続けます。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "これを極端に解釈すると、たとえば 100 万ビットのブロック があり、文字通り 20 問のパリティ チェックを行うことにな り、使用するパリティ ビットは 21 ビットだけになります。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "もちろん、問題は、ブロックが大きくなると、1 つまたは 2 つ以上のビット エラーが 発生する確率が高くなり、ハミング コードがそれを超えるものを処理できないことです。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "しかし、それはまた別の機会にお話します。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "ハミング氏は著書『The Art of Doing Science and Engineering』 の中で、このコードの発見がどれほど曲がりくねったものであったかについて、驚くほど率直に語っています。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "この本の中で、ルイ・パスツールの名言「幸運は準備ができ た心に味方する」という言葉が何度も引用されています。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "しかし、それらは決して明らかではないので、それら が実際には明白であると思い込む必要はありません。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "これは、ビット反転の確率がどれほど高くても、少な くとも理論上は、ある意味、効率的なエラー訂正が 常に可能であることを示した同じ基礎論文でした。",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "数十年が経ち、最近では私たちの多くが断片や情報について考えることに没 頭しているため、この考え方がいかに独特であったかを見落としがちです。",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/korean/sentence_translations.json b/2020/hamming-codes-2/korean/sentence_translations.json
index f344589a6..f4bf4161a 100644
--- a/2020/hamming-codes-2/korean/sentence_translations.json
+++ b/2020/hamming-codes-2/korean/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "우리는 대부분의 비트가 의미 있는 메시지를 전달하는 반면 다른 비트는 일종의 중복 역할을 하는 데이터 블록을 생성하는 방법인 해밍 코드에 대해 이야기하고 있었습니다. 비트 또는 중복 비트 등 이 블록에 있는 모든 항목을 통해 수신자는 오류가 있음을 식별하고 이를 수정하는 방법을 확인할 수 있습니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "거기에 제시된 기본 아이디어는 다중 패리티 검사를 사용하여 오류까지 이진 검색하는 방법이었습니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "예를 들어, 이진수 7은 0111처럼 보입니다. 이는 본질적으로 4 더하기 2 더하기 1을 의미합니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "그리고 위치 7이 어디에 있는지 확인하세요. 이는 패리티 그룹 중 첫 번째, 두 번째, 세 번째에 영향을 주지만 마지막에는 영향을 미치지 않습니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "따라서 이 네 가지 검사 결과를 아래에서 위로 읽으면 실제로 오류의 위치를 알 수 있습니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "이러한 바이너리 레이블을 상자에 다시 넣을 때 실제로 전송되는 데이터와 구별된다는 점을 강조하겠습니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "이는 여러분과 제가 네 개의 패리티 그룹이 어디에서 왔는지 이해하는 데 도움이 되는 개념적 레이블에 지나지 않습니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "우리가 보고 있는 모든 것을 이진법으로 기술하는 것의 우아함은 우리가 보고 있는 모든 것을 이진법으로 기술하는 것의 혼란으로 인해 약화될 수도 있습니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "우리가 얻는 것은 네 개의 패리티 그룹 중 첫 번째입니다. 즉, 첫 번째 검사를 다음과 같이 묻는 것으로 해석할 수 있습니다. 오류가 있으면 해당 오류 위치의 마지막 비트가 1인가요?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "등등.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "첫 번째는 2의 거듭제곱보다 큰 블록 크기를 체계적으로 일반화하는 방법입니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "이는 각 패리티 비트가 4개의 패리티 그룹 중 하나에만 위치한다는 것을 의미합니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "두 비트의 XOR을 수행하면 해당 비트 중 하나가 켜져 있으면 1이 반환되지만 둘 다 켜져 있거나 꺼져 있으면 반환되지 않습니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "다르게 말하면, 이 두 비트의 패리티입니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "그것은 덧셈과 비슷하지만 결코 가지고 다니지 않습니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "여러분과 저에게 중요한 점은 다양한 비트 문자열의 XOR을 취하는 것이 열의 경우와 같이 여러 개별 그룹의 패러디를 한꺼번에 계산하는 효과적인 방법이라는 것입니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "이는 해밍 코드 알고리즘의 다중 패리티 검사를 모두 하나의 단일 작업으로 함께 패키지하는 것으로 생각하는 다소 멋진 방법을 제공합니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "말이 돼?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "마찬가지로 다음 열에서는 두 번째 패리티 그룹에 위치가 몇 개 있는지, 마지막 비트에서 두 번째 비트가 1이고 역시 강조 표시된 위치 등을 계산합니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "이제 이와 같은 결과가 나오면 하단에 있는 4개의 결과 비트가 오류 위치를 직접적으로 설명하는 이유를 생각할 수 있는 정말 좋은 방법을 제공합니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "이 블록의 일부 비트가 0에서 1로 전환된다고 가정해 보겠습니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "이는 해당 비트의 위치가 이제 전체 XOR에 포함되어 합계가 0에서 새로 포함된 값인 오류 위치로 변경된다는 의미입니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "데이터 블록을 시뮬레이션하기 위해 16개의 1과 0으로 구성된 임의의 배열을 생성하는 것부터 시작하고 여기에 이름 비트를 부여할 것입니다. 무작위이므로 5개의 패리티 비트와 함께 11개의 데이터 비트를 전달합니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "그래서 우리가 이 모든 쌍, 즉 i처럼 보이는 쌍을 반복하는 목록을 생성하고 i 값만 추출하고 인덱스만 추출하면 그다지 흥미롭지는 않습니다. 0부터 15까지의 인덱스만 다시 가져옵니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "하지만 만약 비트인 경우에만 이 작업을 수행한다는 조건을 추가하면, 즉 해당 비트가 1이고 0이 아닌 경우 해당 비트가 켜져 있는 위치만 꺼냅니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "여기서는 수행하지 않겠지만 송신자가 이진 표현을 사용하여 필요에 따라 4개의 패리티 비트를 설정하는 함수를 작성할 수 있습니다. 그러면 궁극적으로 이 블록을 전체 비트 목록에서 이 코드 줄을 실행하는 상태가 반환됩니다. 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "멋진 점은 이 목록의 비트 중 하나를 전환하여 노이즈로 인한 임의 오류를 시뮬레이션한 다음 동일한 코드 줄을 실행하면 해당 오류가 인쇄된다는 것입니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "갑자기 이 블록을 가져와서 이 한 줄을 실행하면 오류 위치가 자동으로 표시되고, 오류가 없으면 0이 표시됩니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "이제 바이너리, XOR 및 일반적인 소프트웨어에 대한 편안함에 따라 이 관점이 약간 혼란스러울 수도 있고 훨씬 더 우아하고 단순하여 왜 우리가 처음부터 시작하지 않았는지 궁금해할 수도 있습니다. -가다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "대략적으로 말하면 다중 패리티 검사 관점은 하드웨어에서 해밍 코드를 직접 구현할 때 생각하기가 더 쉽고, XOR 관점은 소프트웨어에서 수행할 때 더 높은 수준에서 생각하기 가장 쉽습니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "여기서 관련 사실은 해당 정보가 필요한 중복 정도와 직접적으로 일치한다는 것입니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "그런데 때로는 해밍 코드가 표시되는 완전히 다른 방식이 있는데, 여기서 메시지에 하나의 큰 행렬을 곱합니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "확장에 관해 말하자면, 블록 크기를 늘릴수록 이 체계의 효율성이 더 좋아진다는 것을 알 수 있습니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "예를 들어, 256비트의 경우 중복성을 위해 해당 공간의 3%만 사용하고 그 이후로 점점 더 좋아지는 것을 확인했습니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "패리티 비트 수가 하나씩 증가함에 따라 블록 크기는 계속 두 배로 늘어납니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "그리고 이를 극단적으로 받아들인다면, 예를 들어 백만 비트의 블록을 가질 수 있습니다. 여기서 패리티 검사로 문자 그대로 20개의 질문을 플레이하고 21개의 패리티 비트만 사용하게 됩니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "물론 문제는 블록이 클수록 비트 오류가 1~2개 이상 나올 확률이 높아지고, 해밍 코드는 그 이상은 처리하지 못한다는 점이다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "그러나 그것은 다른 시간에 다룰 주제입니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "Hamming은 자신의 저서 The Art of Doing Science and Engineering에서 자신이 발견한 이 코드가 얼마나 의미심장한 일이었는지 놀랍도록 솔직하게 밝혔습니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "이 책 전체에 걸쳐 그는 루이 파스퇴르의 명언을 여섯 번이나 언급합니다. 행운은 준비된 마음을 선호합니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "하지만 그것들이 실제로 명백하다고 생각하도록 자신을 속여서는 안 됩니다. 왜냐하면 그것들은 확실히 그렇지 않기 때문입니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "이것은 적어도 이론적으로는 비트 플립 확률이 아무리 높더라도 어떤 의미에서는 효율적인 오류 수정이 항상 가능하다는 것을 보여주는 동일한 기본 논문이었습니다.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "수십 년이 지난 지금, 우리 중 많은 사람들이 비트와 정보에 대한 생각에 너무 몰두하여 이러한 사고 방식이 얼마나 뚜렷한지 간과하기 쉽습니다.",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/marathi/sentence_translations.json b/2020/hamming-codes-2/marathi/sentence_translations.json
index 73b834420..f049cfd70 100644
--- a/2020/hamming-codes-2/marathi/sentence_translations.json
+++ b/2020/hamming-codes-2/marathi/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "आम्ही हॅमिंग कोडबद्दल बोलत होतो, डेटाचा एक ब्लॉक तयार करण्याचा एक मार्ग जिथे बहुतेक बिट एक अर्थपूर्ण संदेश देतात, तर काही इतर एक प्रकारचा रिडंडंसी म्हणून काम करतात, अशा प्रकारे की जर काही बिट फ्लिप झाले तर एकतर संदेश बिट किंवा रिडंडंसी बिट, या ब्लॉकमधील काहीही, एक प्राप्तकर्ता त्रुटी आहे हे ओळखण्यास सक्षम असेल आणि त्याचे निराकरण कसे करावे.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "तेथे सादर केलेली मूलभूत कल्पना ही होती की त्रुटीकडे जाण्यासाठी बायनरी शोधण्यासाठी एकाधिक पॅरिटी चेक कसे वापरायचे.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "उदाहरणार्थ, बायनरी मधील 7 ही संख्या 0111 सारखी दिसते, मूलत: ते 4 अधिक 2 अधिक 1 असे म्हणते.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "आणि लक्षात घ्या की स्थान 7 कुठे बसते, ते आमच्या समता गटांपैकी पहिल्यावर, आणि दुसऱ्या आणि तिसऱ्याला प्रभावित करते, परंतु शेवटचे नाही.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "त्यामुळे तळापासून वरपर्यंत त्या चार तपासण्यांचे निकाल वाचून त्रुटीची स्थिती स्पष्ट होते.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "जसे आम्ही ही बायनरी लेबले त्यांच्या बॉक्समध्ये परत ठेवतो, मी यावर जोर देतो की ते प्रत्यक्षात पाठवलेल्या डेटापेक्षा वेगळे आहेत.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "ते चार समानता गट कुठून आले हे तुम्हाला आणि मला समजण्यास मदत करण्यासाठी एक संकल्पनात्मक लेबलपेक्षा अधिक काही नाही.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "बायनरीमध्ये वर्णन केल्या जाणाऱ्या प्रत्येक गोष्टीचे वर्णन आपण पाहत आहोत या संभ्रमामुळे कदाचित कमी होईल.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "आम्हाला जे मिळते ते आमच्या चार पॅरिटी गटांपैकी पहिले आहे, याचा अर्थ तुम्ही त्या पहिल्या चेकचा विचार म्हणून अर्थ लावू शकता, अरे, जर एखादी त्रुटी असेल, तर त्या त्रुटीच्या स्थितीतील अंतिम बिट 1 आहे का?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "वगैरे.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "प्रथम म्हणजे दोन मोठ्या शक्ती असलेल्या आकारांना ब्लॉक करण्यासाठी पद्धतशीरपणे सामान्यीकरण कसे करावे.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "याचा अर्थ असा आहे की त्या प्रत्येक पॅरिटी बिट्स चार पॅरिटी गटांपैकी फक्त एकामध्ये बसतात.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "जेव्हा तुम्ही दोन बिट्सचा XOR घेता, तेव्हा त्यापैकी एक बिट चालू असल्यास ते 1 परत करेल, परंतु दोन्ही चालू किंवा बंद असल्यास नाही.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "वेगळ्या पद्धतीने शब्दबद्ध केले तर ही या दोन बिट्सची समानता आहे.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "हे जोडण्यासारखे आहे, परंतु जिथे आपण कधीही वाहून नेत नाही.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "तुमच्यासाठी आणि माझ्यासाठी महत्त्वाचा मुद्दा असा आहे की अनेक भिन्न बिट स्ट्रिंग्सचे XOR घेणे हा वेगवेगळ्या गटांच्या विडंबनांची प्रभावीपणे गणना करण्याचा एक मार्ग आहे, जसे की स्तंभांप्रमाणेच, सर्व काही एकाच वेळी होते.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "हे आम्हाला आमच्या हॅमिंग कोड अल्गोरिदममधील एकाधिक समानता तपासण्यांबद्दल विचार करण्याचा एक अतिशय आकर्षक मार्ग देते कारण सर्व एकाच ऑपरेशनमध्ये एकत्रित केले जातात.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "त्याला काही अर्थ आहे का?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "त्याचप्रमाणे, पुढील स्तंभ दुसऱ्या पॅरिटी गटात किती पोझिशन्स आहेत याची मोजणी करतो, ज्या पोझिशन्सचा दुसरा ते शेवटचा बिट 1 आहे आणि ज्या हायलाइट केल्या आहेत, आणि असेच पुढे.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "आता एकदा आमच्याकडे असे झाले की, हे आम्हाला तळाशी असलेले हे चार परिणामी बिट्स थेट त्रुटीची स्थिती का स्पष्ट करतात याबद्दल विचार करण्याचा एक चांगला मार्ग देते.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "समजा या ब्लॉकमध्ये ० ते १ पर्यंत टॉगल केले आहे.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "याचा अर्थ असा आहे की त्या बिटची स्थिती आता एकूण XOR मध्ये समाविष्ट केली जाणार आहे, जी बेरीज 0 वरून बदलते त्याऐवजी हे नवीन समाविष्ट केलेले मूल्य, त्रुटीची स्थिती.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "आम्ही डेटा ब्लॉकचे नक्कल करण्यासाठी 16 1s आणि 0s चा यादृच्छिक अॅरे तयार करून सुरुवात करू आणि मी त्याला नावाचे बिट्स देईन, परंतु अर्थातच सराव मध्ये हे असे काहीतरी असेल जे आम्हाला प्रेषकाकडून प्राप्त होत असेल आणि त्याऐवजी यादृच्छिक असल्याने ते 5 पॅरिटी बिट्ससह 11 डेटा बिट्स घेऊन जाईल.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "मग जर आपण या सर्व जोड्या, i सारख्या दिसणार्‍या जोड्या लूप करणारी यादी तयार केली आणि मग आपण फक्त i मूल्य, फक्त निर्देशांक काढू, तर ते इतके रोमांचक नाही, तर आपल्याला ते निर्देशांक 0 ते 15 परत मिळतात.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "पण जर आपण हे फक्त बिट जर करण्याची अट जोडली, म्हणजे जर तो बिट 1 असेल तर 0 नसेल, तर तो फक्त त्या पोझिशन्स बाहेर काढतो जिथे संबंधित बिट चालू आहे.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "आम्ही ते येथे करणार नाही, परंतु तुम्ही एक फंक्शन लिहू शकता जिथे प्रेषक आवश्यकतेनुसार चार पॅरिटी बिट्स सेट करण्यासाठी बायनरी प्रतिनिधित्व वापरतो, शेवटी हा ब्लॉक अशा स्थितीत आणतो जिथे कोडची ही ओळ बिट्सच्या संपूर्ण यादीवर चालते. एक 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "काय छान आहे की जर आपण या यादीतील कोणत्याही एका बिट्सला टॉगल केले, नॉइजमधून यादृच्छिक त्रुटीचे नक्कल करून, जर तुम्ही कोडची हीच ओळ चालवली तर ती त्रुटी प्रिंट करते.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "तुम्ही हा ब्लॉक निळ्या रंगातून मिळवू शकता, त्यावर ही एकल ओळ चालवा आणि ती आपोआप त्रुटीची स्थिती बाहेर टाकेल, किंवा जर नसेल तर 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "आता, बायनरी आणि XORs आणि सर्वसाधारणपणे सॉफ्टवेअरसह तुमच्या सोयीनुसार, तुम्हाला एकतर हा दृष्टीकोन थोडा गोंधळात टाकणारा किंवा इतका अधिक मोहक आणि सोपा वाटू शकतो की, आम्ही सुरुवातीपासूनच याची सुरुवात का केली नाही याचा तुम्हाला प्रश्न पडतो.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "- जा हलक्या शब्दात सांगायचे तर, हार्डवेअरमध्ये हॅमिंग कोडची अंमलबजावणी करताना मल्टीपल पॅरिटी चेक दृष्टीकोन विचार करणे सोपे आहे, आणि XOR दृष्टीकोन हे सॉफ्टवेअरमध्ये करत असताना विचार करणे सर्वात सोपा आहे.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "येथे संबंधित वस्तुस्थिती अशी आहे की ती माहिती आपल्याला किती रिडंडन्सीची आवश्यकता आहे याच्याशी थेट संबंधित आहे.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "आणि मग, तसे, हा संपूर्ण दुसरा मार्ग आहे ज्यामध्ये आपण कधीकधी हॅमिंग कोड सादर केलेले दिसतो, जिथे आपण संदेश एका मोठ्या मॅट्रिक्सने गुणाकार करतो.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "आणि स्केलिंगबद्दल बोलताना, तुमच्या लक्षात येईल की या योजनेची कार्यक्षमता केवळ आम्ही ब्लॉक आकार वाढवतो तेव्हाच अधिक चांगली होते.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "उदाहरणार्थ, आम्ही पाहिले की 256 बिट्ससह, तुम्ही त्यातील केवळ 3% जागा रिडंडंसीसाठी वापरत आहात आणि ते तिथून चांगले होत आहे.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "पॅरिटी बिट्सची संख्या एक एक करून वाढत असताना, ब्लॉकचा आकार दुप्पट होत जातो.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "आणि जर तुम्ही ते टोकापर्यंत नेले, तर तुमच्याकडे एक दशलक्ष बिट्सचा ब्लॉक असू शकतो, जिथे तुम्ही तुमच्या पॅरिटी चेकसह अक्षरशः 20 प्रश्न खेळत असाल आणि ते फक्त 21 पॅरिटी बिट्स वापरते.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "अर्थातच, समस्या अशी आहे की मोठ्या ब्लॉकसह, एक किंवा दोन बिट त्रुटींपेक्षा जास्त दिसण्याची शक्यता वाढते आणि हॅमिंग कोड त्यापलीकडे काहीही हाताळत नाहीत.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "पण तो दुसर्‍या वेळी विषय आहे.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "त्याच्या द आर्ट ऑफ डुइंग सायन्स अँड इंजिनीअरिंग या पुस्तकात, हॅमिंगने या कोडचा शोध किती क्षुल्लक होता हे आश्चर्यकारकपणे स्पष्ट केले आहे.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "या पुस्तकात अर्धा डझन वेळा त्यांनी लुई पाश्चरच्या कोटाचा संदर्भ दिला आहे, नशीब तयार मनाला अनुकूल आहे.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "परंतु ते प्रत्यक्षात स्पष्ट आहेत असा विचार करून तुम्ही स्वत:ला फसवू नका, कारण ते नक्कीच नाहीत.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "हा तोच पायाभूत कागद होता ज्याने एका विशिष्ट अर्थाने दाखवून दिले की, किमान सिद्धांतानुसार, बिट फ्लिपची संभाव्यता कितीही उच्च असली तरीही कार्यक्षम त्रुटी सुधारणे नेहमीच शक्य असते.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "अनेक दशके फास्ट फॉरवर्ड, आणि आजकाल, आपल्यापैकी बरेच जण बिट्स आणि माहितीबद्दल विचार करण्यात इतके मग्न आहेत की विचार करण्याची ही पद्धत किती वेगळी होती याकडे दुर्लक्ष करणे सोपे आहे.",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/persian/sentence_translations.json b/2020/hamming-codes-2/persian/sentence_translations.json
index 33598f287..a76927d42 100644
--- a/2020/hamming-codes-2/persian/sentence_translations.json
+++ b/2020/hamming-codes-2/persian/sentence_translations.json
@@ -1,6 +1,6 @@
 [
  {
-  "input": "I'm assuming that everybody here is coming from part 1. ",
+  "input": "I'm assuming that everybody here is coming from part 1.",
   "translatedText": "من فرض می کنم که همه اینجا از قسمت 1 آمده اند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it. ",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "ما در مورد کدهای همینگ صحبت می‌کردیم، راهی برای ایجاد یک بلوک از داده‌ها که در آن بیشتر بیت‌ها پیامی معنادار دارند، در حالی که چند بیت دیگر به‌عنوان نوعی افزونگی عمل می‌کنند، به گونه‌ای که اگر بیتی برگردانده شد، یا یک پیام. بیت یا بیت افزونگی، هر چیزی در این بلوک، گیرنده می‌تواند تشخیص دهد که یک خطا وجود داشته است، و چگونه آن را برطرف کند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error. ",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "ایده اصلی ارائه شده در آنجا این بود که چگونه از چندین بررسی برابری برای جستجوی باینری برای رسیدن به خطا استفاده کنید. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -24,7 +24,7 @@
   "end": 27.16
  },
  {
-  "input": "In that video the goal was to make Hamming codes feel as hands-on and rediscoverable as possible. ",
+  "input": "In that video the goal was to make Hamming codes feel as hands-on and rediscoverable as possible.",
   "translatedText": "در آن ویدئو، هدف این بود که کدهای همینگ را تا حد امکان به صورت دستی و قابل کشف مجدد ایجاد کنیم. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -32,7 +32,7 @@
   "end": 34.6
  },
  {
-  "input": "hat there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error. In that video, the goal was to make Hamming codes feel as hands-on and rediscoverable as possible. But as ",
+  "input": "But as you start to think about actually implementing this, either in software or hardware, that framing may actually undersell how elegant these codes really are.",
   "translatedText": "اما وقتی شروع به فکر کردن در مورد اجرای واقعی این کدها، چه در نرم‌افزار یا سخت‌افزار، می‌کنید، این قاب‌بندی ممکن است واقعاً از ظریف بودن این کدها کم‌فروش کند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -40,7 +40,7 @@
   "end": 43.46
  },
  {
-  "input": "You might think that you need to write an algorithm that keeps track of all the possible error locations and cuts that group in half with each check, but it's actually way, way simpler than that. ",
+  "input": "You might think that you need to write an algorithm that keeps track of all the possible error locations and cuts that group in half with each check, but it's actually way, way simpler than that.",
   "translatedText": "ممکن است فکر کنید که باید الگوریتمی بنویسید که تمام مکان‌های خطای احتمالی را ردیابی کند و با هر بررسی آن گروه را به نصف کاهش دهد، اما در واقع بسیار ساده‌تر از این است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -48,7 +48,7 @@
   "end": 53.48
  },
  {
-  "input": "If you read out the answers to the four parity checks we did in the last video, all as 1s and 0s instead of yeses and nos, it literally spells out the position of the error in binary. ",
+  "input": "If you read out the answers to the four parity checks we did in the last video, all as 1s and 0s instead of yeses and nos, it literally spells out the position of the error in binary.",
   "translatedText": "اگر پاسخ‌های چهار بررسی برابری را که در ویدیوی گذشته انجام دادیم، به‌جای بله و خیر به صورت 1 و 0 بخوانید، به معنای واقعی کلمه موقعیت خطا را در باینری مشخص می‌کند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "you read out the answers to the four parity checks we did in the last video, all as ones and zeros instead of yeses and nos, it literally spells out ",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "به عنوان مثال، عدد 7 در باینری شبیه 0111 است، که در اصل می گوید که 4 به علاوه 2 به علاوه 1 است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last. ",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "و توجه کنید که موقعیت 7 در کجا قرار می گیرد، اولین گروه از گروه های برابری ما را تحت تاثیر قرار می دهد، و دوم، و سوم، اما نه آخرین. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day. The goal here is to give you a very thorough understanding of one of the earlie ",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "بنابراین خواندن نتایج آن چهار بررسی از پایین به بالا واقعاً موقعیت خطا را مشخص می کند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -80,7 +80,7 @@
   "end": 87.54
  },
  {
-  "input": "st examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity groups, and the second, and the third, but not the last. So reading the results of those four checks ",
+  "input": "There's nothing special about the example 7, this works in general, and this makes the logic for implementing the whole scheme in hardware shockingly simple.",
   "translatedText": "هیچ چیز خاصی در مورد مثال 7 وجود ندارد، این به طور کلی کار می کند، و این منطق اجرای کل طرح در سخت افزار را به طرز تکان دهنده ای ساده می کند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -88,7 +88,7 @@
   "end": 95.82
  },
  {
-  "input": "Now if you want to see why this magic happens, take these 16 index labels for our positions, but instead of writing them in base 10, let's write them all in binary, running from 0000 up to 1111. ",
+  "input": "Now if you want to see why this magic happens, take these 16 index labels for our positions, but instead of writing them in base 10, let's write them all in binary, running from 0000 up to 1111.",
   "translatedText": "حالا اگر می‌خواهید ببینید چرا این جادو اتفاق می‌افتد، این 16 برچسب شاخص را برای موقعیت‌های ما انتخاب کنید، اما به جای نوشتن آنها در پایه 10، بیایید همه آنها را به صورت باینری بنویسیم، از 0000 تا 1111 اجرا شود. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent. ",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "همانطور که این برچسب‌های باینری را دوباره در جعبه‌هایشان قرار می‌دهیم، اجازه دهید تأکید کنم که آنها از داده‌هایی که واقعاً ارسال می‌شوند متمایز هستند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from. ",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "آنها چیزی بیش از یک برچسب مفهومی برای کمک به من و شما نیستند که بفهمیم چهار گروه برابری از کجا آمده اند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary. ",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "ظرافت داشتن هر چیزی که ما به آن نگاه می کنیم به صورت باینری توصیف می شود، شاید به دلیل سردرگمی توصیف شدن هر چیزی که ما به آن نگاه می کنیم به صورت دودویی تضعیف شود. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -120,7 +120,7 @@
   "end": 132.36
  },
  {
-  "input": "0, let's write them all in binary, running from 0000 up to 1111. ask feels at the star ",
+  "input": "It's worth it, though.",
   "translatedText": "هرچند ارزشش را دارد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -128,7 +128,7 @@
   "end": 134.12
  },
  {
-  "input": "Focus your attention just on that last bit of all of these labels, and then highlight the positions where that final bit is a 1. ",
+  "input": "Focus your attention just on that last bit of all of these labels, and then highlight the positions where that final bit is a 1.",
   "translatedText": "توجه خود را فقط روی آخرین بیت تمام این برچسب ها متمرکز کنید و سپس موقعیت هایی را که بیت نهایی 1 است، برجسته کنید. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1? ",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "چیزی که دریافت می کنیم اولین گروه از چهار گروه برابری ما است، به این معنی که می توانید اولین بررسی را به این صورت تفسیر کنید که اگر خطایی وجود دارد، آیا بیت نهایی در موقعیت آن خطا 1 است؟ به طور مشابه، اگر روی بیت دوم تا آخر تمرکز کنید و تمام موقعیت‌هایی را که در آن 1 است برجسته کنید، گروه برابری دوم را از طرح ما دریافت می‌کنید. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -144,7 +144,7 @@
   "end": 155.74
  },
  {
-  "input": "Similarly, if you focus on the second to last bit, and highlight all the positions where that's a 1, you get the second parity group from our scheme. ",
+  "input": "Similarly, if you focus on the second to last bit, and highlight all the positions where that's a 1, you get the second parity group from our scheme.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -152,7 +152,7 @@
   "end": 166.16
  },
  {
-  "input": "ly spelled words. Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. ",
+  "input": "In other words, that second check is asking, hey, me again, if there's an error, is the second to last bit of that position a 1?",
   "translatedText": "به عبارت دیگر، آن چک دوم از شما می پرسد، دوباره سلام، اگر خطایی وجود دارد، آیا بیت دوم تا آخر آن موقعیت 1 است؟ و غیره. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "And so on. ",
+  "input": "And so on.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -168,7 +168,7 @@
   "end": 176.9
  },
  {
-  "input": "The third parity check covers every position whose third to last bit is turned on, and the last one covers the last eight positions, those ones whose highest order bit is a 1. ",
+  "input": "The third parity check covers every position whose third to last bit is turned on, and the last one covers the last eight positions, those ones whose highest order bit is a 1.",
   "translatedText": "بررسی برابری سوم هر موقعیتی را که بیت سوم تا آخرین بیت آن روشن است و آخرین مورد هشت موقعیت آخر را پوشش می دهد، آنهایی که بالاترین بیت مرتبه آنها 1 است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -176,7 +176,7 @@
   "end": 188.74
  },
  {
-  "input": "everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary. ",
+  "input": "Everything we did earlier is the same as answering these four questions, which in turn is the same as spelling out a position in binary.",
   "translatedText": "هر کاری که قبلا انجام دادیم مانند پاسخ دادن به این چهار سوال است، که به نوبه خود مانند املای یک موقعیت در باینری است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -184,7 +184,7 @@
   "end": 197.74
  },
  {
-  "input": "It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where tha ",
+  "input": "I hope this makes two things clearer.",
   "translatedText": "امیدوارم این دو چیز را واضح تر کند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "t final bit is a 1. What we get is the first of our four parity groups, which means that you can interpret that first check as asking, hey, if there's an err ",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "اولین مورد این است که چگونه به طور سیستماتیک به اندازه های بلوکی که قدرت های دو بزرگتر هستند تعمیم دهیم. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -200,7 +200,7 @@
   "end": 206.46
  },
  {
-  "input": "If it takes more bits to describe each position, like six bits to describe 64 spots, then each of those bits gives you one of the parity groups that we need to check. ",
+  "input": "If it takes more bits to describe each position, like six bits to describe 64 spots, then each of those bits gives you one of the parity groups that we need to check.",
   "translatedText": "اگر برای توصیف هر موقعیت، بیت‌های بیشتری طول می‌کشد، مانند شش بیت برای توصیف 64 نقطه، هر کدام از آن بیت‌ها یکی از گروه‌های برابری را به شما می‌دهند که باید بررسی کنیم. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -208,7 +208,7 @@
   "end": 216.68
  },
  {
-  "input": "maybe at the end or something like that, but as you'll see, having them sit in positions which are powers of 2 allows for something that's really elegant by the end. ",
+  "input": "Those of you who watched the chessboard puzzle I did with Matt Parker might find all this exceedingly familiar.",
   "translatedText": "کسانی از شما که پازل صفحه شطرنج را که من با مت پارکر انجام دادم تماشا کردند، ممکن است همه اینها را بسیار آشنا بیابند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -216,7 +216,7 @@
   "end": 223.18
  },
  {
-  "input": "It's the same core logic, but solving a different problem, and applied to a 64-squared chessboard. ",
+  "input": "It's the same core logic, but solving a different problem, and applied to a 64-squared chessboard.",
   "translatedText": "این همان منطق اصلی است، اما حل یک مشکل متفاوت، و در یک صفحه شطرنج 64 مربع اعمال می شود. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -224,7 +224,7 @@
   "end": 228.78
  },
  {
-  "input": "The second thing I hope this makes clear is why our parity bits are sitting in the positions that are powers of two, for example 1, 2, 4, and 8. ",
+  "input": "The second thing I hope this makes clear is why our parity bits are sitting in the positions that are powers of two, for example 1, 2, 4, and 8.",
   "translatedText": "دومین چیزی که امیدوارم روشن شود این است که چرا بیت های برابری ما در موقعیت هایی قرار دارند که قدرت های دو هستند، برای مثال 1، 2، 4 و 8. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -232,7 +232,7 @@
   "end": 237.32
  },
  {
-  "input": "at goes on at position 0, but don't worry about that for now. The third parity check covers every position whose third to last bit is turned ",
+  "input": "These are the positions whose binary representation has just a single bit turned on.",
   "translatedText": "اینها موقعیت هایی هستند که نمایش باینری آنها فقط یک بیت روشن است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups. ",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "این بدان معناست که هر یک از آن بیت های برابری در یک و تنها یکی از چهار گروه برابری قرار می گیرند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -248,7 +248,7 @@
   "end": 249.46
  },
  {
-  "input": "You can also see this in larger examples, where no matter how big you get, each parity bit conveniently touches only one of the groups. ",
+  "input": "You can also see this in larger examples, where no matter how big you get, each parity bit conveniently touches only one of the groups.",
   "translatedText": "همچنین می‌توانید این را در نمونه‌های بزرگ‌تر ببینید، جایی که مهم نیست چقدر بزرگ می‌شوید، هر بیت برابری به راحتی تنها یکی از گروه‌ها را لمس می‌کند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -256,7 +256,7 @@
   "end": 259.34
  },
  {
-  "input": "Once you understand that these parity checks that we've focused so much of our time on are nothing more than a clever way to spell out the position of an error in binary, then we can draw a connection with a different way to think about hamming codes, one that is arguably a lot simpler and more elegant, and which can basically be written down with a single line of code. ",
+  "input": "Once you understand that these parity checks that we've focused so much of our time on are nothing more than a clever way to spell out the position of an error in binary, then we can draw a connection with a different way to think about hamming codes, one that is arguably a lot simpler and more elegant, and which can basically be written down with a single line of code.",
   "translatedText": "هنگامی که متوجه شدید که این بررسی‌های برابری که ما بیشتر وقت خود را بر روی آنها متمرکز کرده‌ایم، چیزی جز روشی هوشمندانه برای مشخص کردن موقعیت یک خطا در باینری نیست، آنگاه می‌توانیم با روشی متفاوت برای تفکر در مورد همینگ ارتباط برقرار کنیم. کدهایی که مسلماً بسیار ساده‌تر و ظریف‌تر هستند و اساساً می‌توان آن‌ها را با یک خط کد نوشت. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -264,7 +264,7 @@
   "end": 283.24
  },
  {
-  "input": "It's based on the XOR function. ",
+  "input": "It's based on the XOR function.",
   "translatedText": "این بر اساس تابع XOR است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -272,7 +272,7 @@
   "end": 285.5
  },
  {
-  "input": "f 1s in the message is an even number. So for example right now, that total number of 1s is If it takes more bits to describe each p ",
+  "input": "XOR, for those of you who don't know, stands for exclusive or.",
   "translatedText": "XOR، برای کسانی از شما که نمی دانند، مخفف منحصر به فرد یا. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "osition, like six bits to describe 64 spots, then each of those bits gives you one of the parity groups that we need to check. that special bit to be a 1, making the count even. But if the block had already started off with a ",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "هنگامی که XOR دو بیت را می گیرید، اگر یکی از آن بیت ها روشن باشد، 1 برمی گردد، اما اگر هر دو روشن یا خاموش باشند، نه. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "Phrased differently, it's the parity of these two bits. ",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "با بیان متفاوت، برابری این دو بیت است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -296,7 +296,7 @@
   "end": 302.98
  },
  {
-  "input": "it would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core ",
+  "input": "As a math person, I prefer to think about it as addition mod 2.",
   "translatedText": "به عنوان یک فرد ریاضی، ترجیح می دهم در مورد آن به عنوان مد 2 فکر کنم. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -304,7 +304,7 @@
   "end": 306.76
  },
  {
-  "input": "logic, but solving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity bits are sitti ",
+  "input": "We also commonly talk about the XOR of two different bit strings, which basically does this component by component.",
   "translatedText": "ما همچنین معمولاً در مورد XOR دو رشته بیت مختلف صحبت می کنیم که اساساً این جزء به جزء انجام می شود. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "It's like addition, but where you never carry. ",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "این مانند اضافه است، اما جایی که هرگز حمل نمی کنید. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -320,7 +320,7 @@
   "end": 315.72
  },
  {
-  "input": "Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. ",
+  "input": "Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2.",
   "translatedText": "باز هم، کسانی که تمایل بیشتری به ریاضی دارند ممکن است ترجیح دهند این را به عنوان افزودن دو بردار و کاهش mod 2 در نظر بگیرند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -328,7 +328,7 @@
   "end": 322.48
  },
  {
-  "input": "of two, for example 1, 2, 4, and 8. These are the positions whose binary representation has just a single bit turned on. d say the parity is 0 or 1, which is typically more helpful once you start doing math with the idea. And this special bit that the sender uses to con ",
+  "input": "If you open up some Python right now and apply the caret operation between two integers, this is what it's doing but to the bit representations of those numbers under the hood.",
   "translatedText": "اگر همین الان پایتون را باز کنید و عملیات caret را بین دو عدد صحیح اعمال کنید، این همان کاری است که انجام می‌دهد به جز نمایش بیت‌های آن اعداد زیر سرپوش. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "trol the parity is called the parity bit. And actually, we should be clear, if the receiver sees an odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure tha ",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "نکته کلیدی برای من و شما این است که گرفتن XOR از بسیاری از رشته‌های بیتی مختلف، به طور موثر راهی برای محاسبه تقلید هجو دسته‌ای از گروه‌های جداگانه است، مانند ستون‌ها، همه در یک لحظه. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation. ",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "این به ما یک روش نسبتاً جالب می دهد تا در مورد بررسی های برابری چندگانه از الگوریتم کد Hamming خود فکر کنیم زیرا همه با هم در یک عملیات واحد بسته بندی می شوند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -352,7 +352,7 @@
   "end": 358.78
  },
  {
-  "input": "Though at first glance it does look very different. ",
+  "input": "Though at first glance it does look very different.",
   "translatedText": "اگرچه در نگاه اول بسیار متفاوت به نظر می رسد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -360,7 +360,7 @@
   "end": 362.18
  },
  {
-  "input": "Specifically write down the 16 positions in binary, like we had before, and now highlight the positions where the message bit is turned on to a 1, and then collect these positions into one big column and take the XOR. ",
+  "input": "Specifically write down the 16 positions in binary, like we had before, and now highlight the positions where the message bit is turned on to a 1, and then collect these positions into one big column and take the XOR.",
   "translatedText": "به طور خاص 16 موقعیت را به صورت باینری بنویسید، همانطور که قبلاً داشتیم، و اکنون موقعیت هایی را که بیت پیام در آنها روشن است به 1 برجسته کنید، و سپس این موقعیت ها را در یک ستون بزرگ جمع کنید و XOR را بگیرید. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -368,7 +368,7 @@
   "end": 377.1
  },
  {
-  "input": "You can probably guess that the 4 bits sitting at the bottom as a result are the same as the 4 parity checks we've come to know and love, but take a moment to actually think about why exactly. ",
+  "input": "You can probably guess that the 4 bits sitting at the bottom as a result are the same as the 4 parity checks we've come to know and love, but take a moment to actually think about why exactly.",
   "translatedText": "احتمالاً می‌توانید حدس بزنید که 4 بیتی که در نتیجه پایین قرار می‌گیرند، همان 4 بررسی برابری هستند که ما می‌شناسیم و دوستش داریم، اما لحظه‌ای وقت بگذارید و واقعاً به این فکر کنید که چرا دقیقاً چرا. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -376,7 +376,7 @@
   "end": 389.2
  },
  {
-  "input": "This last column, for example, is counting all of the positions whose last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. ",
+  "input": "This last column, for example, is counting all of the positions whose last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group.",
   "translatedText": "برای مثال، این آخرین ستون، تمام موقعیت‌هایی را که آخرین بیت آنها 1 است، می‌شمرد، اما ما در حال حاضر فقط به موقعیت‌های برجسته‌شده محدود شده‌ایم، بنابراین به طور موثر شمارش می‌کند که چند موقعیت برجسته از گروه برابری اول آمده است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is ",
+  "input": "Does that make sense?",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "turned on, but not if both are turned on or if both are turned off. Phrased differently, it's the parity of these two bits. full message down to a single bit, what they give us is a powerful building block for more sophisticated schemes. ",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "فرقی میکنه؟ به همین ترتیب، ستون بعدی تعداد موقعیت‌های گروه برابری دوم، موقعیت‌هایی که بیت دوم تا آخر آنها 1 است و همچنین برجسته شده‌اند و غیره می‌شمارند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -400,7 +400,7 @@
   "end": 420.0
  },
  {
-  "input": "It's really just a small shift in perspective on the same thing we've been doing. ",
+  "input": "It's really just a small shift in perspective on the same thing we've been doing.",
   "translatedText": "این واقعاً فقط یک تغییر کوچک در دیدگاه نسبت به همان کاری است که ما انجام می‌دادیم. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -408,7 +408,7 @@
   "end": 423.96
  },
  {
-  "input": "e also commonly talk about the XOR of two different bit s ",
+  "input": "And so you know where it goes from here.",
   "translatedText": "و بنابراین می دانید که از اینجا به کجا می رود. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -416,7 +416,7 @@
   "end": 429.6
  },
  {
-  "input": "The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000. ",
+  "input": "The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
   "translatedText": "فرستنده مسئول تغییر برخی از بیت های برابری ویژه است تا مطمئن شود که مجموع آنها 0000 است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error. ",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "حالا وقتی آن را به این شکل داشته باشیم، این روش واقعاً خوبی به ما می دهد تا فکر کنیم چرا این چهار بیت حاصل در پایین به طور مستقیم موقعیت یک خطا را مشخص می کنند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "Let's say some bit in this block gets toggled from a 0 to a 1. ",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "فرض کنید مقداری از بیت در این بلوک از 0 به 1 تغییر می کند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. ",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "معنی آن این است که موقعیت آن بیت اکنون در XOR کل گنجانده می شود، که مجموع را از 0 به جای این مقدار جدید اضافه شده، یعنی موقعیت خطا، تغییر می دهد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -448,7 +448,7 @@
   "end": 463.82
  },
  {
-  "input": "Slightly less obviously, the same is true if there's an error that changes a 1 to a 0. ",
+  "input": "Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
   "translatedText": "واضح است که کمی کمتر، اگر خطایی وجود داشته باشد که 1 را به 0 تغییر دهد، همین امر صادق است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -456,7 +456,7 @@
   "end": 469.36
  },
  {
-  "input": "ey point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop. This gives us a rather snazzy way ",
+  "input": "You see, if you add a bit string together twice, it's the same as not having it there at all, basically because in this world 1 plus 1 equals 0.",
   "translatedText": "ببینید، اگر یک رشته بیت را دو بار با هم اضافه کنید، مثل این است که اصلاً آن را نداشته باشید، اساساً به این دلیل که در این دنیا 1 به اضافه 1 برابر با 0 است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -464,7 +464,7 @@
   "end": 477.94
  },
  {
-  "input": "to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation. ",
+  "input": "So adding a copy of this position to the total sum has the same effect as we're moving it.",
   "translatedText": "بنابراین افزودن یک کپی از این موقعیت به مجموع کل همان اثری را دارد که ما آن را جابجا می کنیم. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -472,7 +472,7 @@
   "end": 484.3
  },
  {
-  "input": "Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the mes ",
+  "input": "And that effect, again, is that the total result at the bottom here spells out the position of the error.",
   "translatedText": "و آن اثر، دوباره، این است که نتیجه کل در پایین اینجا موقعیت خطا را مشخص می کند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -480,7 +480,7 @@
   "end": 490.7
  },
  {
-  "input": "sage bit is turned on to a 1, and then collect these positions into one big column and take the XOR. You can probably guess that the four bits sitting at the bottom as a resu ",
+  "input": "To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all of the logic on the receiver's end.",
   "translatedText": "برای نشان دادن زیبایی این موضوع، اجازه دهید یک خط از کد پایتون را که قبلاً به آن ارجاع دادم نشان دهم، که تقریباً تمام منطق انتهای گیرنده را نشان می‌دهد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "lt are the same as the four parity checks we've come to know and love, but take a moment to actually think about why exactly. This last column, for example, is counting all of the positions whose last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. ",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "ما با ایجاد یک آرایه تصادفی از 16 1 و 0 برای شبیه سازی بلوک داده شروع می کنیم، و من بیت های نام را به آن می دهم، اما البته در عمل این چیزی است که ما از فرستنده دریافت می کنیم، و به جای تصادفی بودن، 11 بیت داده همراه با 5 بیت برابری را حمل می کند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -496,7 +496,7 @@
   "end": 517.4
  },
  {
-  "input": "If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15. ",
+  "input": "If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
   "translatedText": "اگر تابع enumerateBits را صدا بزنم، کاری که انجام می دهد این است که هر یک از آن بیت ها را با یک شاخص مربوطه جفت می کند، در این مورد از 0 تا 15 اجرا می شود. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ht half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit, so these 8 bits already have an even pari Likewise, the next column counts how many positions are in the second parity group, the positions whose second to las ",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "بنابراین، اگر لیستی ایجاد کنیم که روی همه این جفت‌ها حلقه بزند، جفت‌هایی که شبیه i هستند، و سپس فقط مقدار i، فقط شاخص را بیرون بیاوریم، خوب آنقدرها هم هیجان‌انگیز نیست، فقط آن شاخص‌ها را از 0 تا 15 برمی‌گردانیم. . ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on. ",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "اما اگر شرط را اضافه کنیم که فقط اگر بیت این کار را انجام دهد، به این معنی که اگر آن بیت 1 باشد و 0 نباشد، خوب آنگاه فقط موقعیت هایی را که بیت مربوطه روشن است بیرون می کشد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -520,7 +520,7 @@
   "end": 552.66
  },
  {
-  "input": "ve on the same thing we've been doing. but for right now we're going to assume ",
+  "input": "In this case it looks like those positions are 0, 4, 6, 9, etc.",
   "translatedText": "در این حالت به نظر می رسد که آن موقعیت ها 0، 4، 6، 9 و غیره هستند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -528,7 +528,7 @@
   "end": 557.96
  },
  {
-  "input": "What we want is to collect together all of those positions, the positions of the bits that are turned on, and then XOR them together. ",
+  "input": "What we want is to collect together all of those positions, the positions of the bits that are turned on, and then XOR them together.",
   "translatedText": "چیزی که می‌خواهیم این است که همه آن موقعیت‌ها، موقعیت‌های بیت‌هایی که روشن شده‌اند را جمع‌آوری کنیم و سپس آنها را با هم XOR کنیم. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -536,7 +536,7 @@
   "end": 567.24
  },
  {
-  "input": "The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 000 ",
+  "input": "To do this in Python, let me first import a couple helpful functions.",
   "translatedText": "برای انجام این کار در پایتون، اجازه دهید ابتدا چند تابع مفید را وارد کنم. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -544,7 +544,7 @@
   "end": 573.22
  },
  {
-  "input": "That way we can call reduce() on this list, and use the XOR function to reduce it. ",
+  "input": "That way we can call reduce() on this list, and use the XOR function to reduce it.",
   "translatedText": "به این ترتیب می‌توانیم ()reduce را در این لیست فراخوانی کنیم و از تابع XOR برای کاهش آن استفاده کنیم. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -552,7 +552,7 @@
   "end": 578.7
  },
  {
-  "input": "es us a really nice way to think about why these four resulting bits at the bottom directly spell out the pos ",
+  "input": "This basically eats its way through the list, taking XORs along the way.",
   "translatedText": "این اساساً راه خود را از طریق لیست می خورد و XOR ها را در طول راه می برد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -560,7 +560,7 @@
   "end": 582.68
  },
  {
-  "input": "ition of an error. Let's say you detect an error among the odd columns, and among the right half. It necessarily means the error is somewhere in th ",
+  "input": "If you prefer, you can explicitly write out that XOR function without having to import it from anywhere.",
   "translatedText": "اگر ترجیح می دهید، می توانید به صراحت آن تابع XOR را بدون نیاز به وارد کردن آن از جایی بنویسید. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -568,7 +568,7 @@
   "end": 589.44
  },
  {
-  "input": "So at the moment it looks like if we do this on our random block of 16 bits, it returns 9, which has the binary representation 1001. ",
+  "input": "So at the moment it looks like if we do this on our random block of 16 bits, it returns 9, which has the binary representation 1001.",
   "translatedText": "بنابراین در حال حاضر به نظر می رسد که اگر این کار را روی بلوک تصادفی 16 بیتی خود انجام دهیم، 9 را برمی گرداند که نمایش باینری 1001 دارد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0. ",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "ما این کار را در اینجا انجام نمی دهیم، اما می توانید تابعی بنویسید که در آن فرستنده از آن نمایش باینری برای تنظیم چهار بیت برابری در صورت نیاز استفاده کند، در نهایت این بلوک به حالتی می رسد که اجرای این خط کد در لیست کامل بیت ها برمی گردد. یک 0. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -584,7 +584,7 @@
   "end": 615.46
  },
  {
-  "input": "This would be considered a well-prepared block. ",
+  "input": "This would be considered a well-prepared block.",
   "translatedText": "این یک بلوک به خوبی آماده شده در نظر گرفته می شود. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. ",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "نکته جالب این است که اگر هر یک از بیت‌های این لیست را تغییر دهیم، یک خطای تصادفی از نویز را شبیه‌سازی کنیم، سپس اگر همین خط کد را اجرا کنید، آن خطا را چاپ می‌کند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -600,7 +600,7 @@
   "end": 630.22
  },
  {
-  "input": "an error that changes a 1 to a 0. You see, if you add a bit string together twice, it's the same as ",
+  "input": "Isn't that neat?",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any. ",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "این تمیز نیست؟ می‌توانید این بلوک را از حالت آبی دریافت کنید، این خط را روی آن اجرا کنید و به طور خودکار موقعیت یک خطا یا 0 را در صورت نبودن نشان می‌دهد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -616,7 +616,7 @@
   "end": 641.06
  },
  {
-  "input": "And that effect, again, is that the total result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me sh ",
+  "input": "And there's nothing special about the size 16 here.",
   "translatedText": "و هیچ چیز خاصی در مورد سایز 16 در اینجا وجود ندارد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -624,7 +624,7 @@
   "end": 645.2
  },
  {
-  "input": "The same line of code would work if you had a list of, say, 256 bits. ",
+  "input": "The same line of code would work if you had a list of, say, 256 bits.",
   "translatedText": "اگر لیستی از مثلاً 256 بیت داشته باشید، همان خط کد کار می کند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -632,7 +632,7 @@
   "end": 649.86
  },
  {
-  "input": "ferenced before, which will capture almost all of the logic on the receiver's end. We'll start by creating a random array of 16 ones and zeros to simulate the data block, and I'll go ahead and give it the name bits, but of course in practice this would be something that we're receiving f ",
+  "input": "Needless to say, there is more code to write here, like doing the meta parity check to detect 2-bit errors, but the idea is that almost all of the core logic from our scheme comes down to a single XOR reduction.",
   "translatedText": "نیازی به گفتن نیست، کدهای بیشتری برای نوشتن در اینجا وجود دارد، مانند انجام بررسی متا برابری برای تشخیص خطاهای 2 بیتی، اما ایده این است که تقریباً تمام منطق اصلی طرح ما به یک کاهش XOR منتهی می شود. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. ",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "اکنون، بسته به راحتی شما با باینری و XOR و به طور کلی نرم افزار، ممکن است این دیدگاه را کمی گیج کننده بیابید، یا آنقدر زیباتر و ساده تر که تعجب کنید که چرا ما از ابتدا با آن شروع نکردیم. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level. ",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "-برو به زبان ساده، در هنگام پیاده‌سازی کدهای همینگ در سخت‌افزار به‌طور مستقیم می‌توان به دیدگاه بررسی برابری چندگانه فکر کرد، و در هنگام انجام آن در نرم‌افزار، از سطح بالاتر، راحت‌تر به دیدگاه XOR فکر می‌شود. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -656,7 +656,7 @@
   "end": 690.5
  },
  {
-  "input": "l out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on. In this case it looks like those positions are 0, 4, 6, 9, etc. Remember, what ",
+  "input": "The first one is easiest to actually do by hand, and I think it does a better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the log of the size of the block, or in other words, it grows one bit at a time as the block size doubles.",
   "translatedText": "اولین مورد ساده‌ترین کار است که واقعاً با دست انجام می‌شود، و من فکر می‌کنم با القای شهود اصلی زیربنای همه این‌ها کار بهتری انجام می‌دهد، یعنی اطلاعات مورد نیاز برای یافتن یک خطا مربوط به گزارش اندازه بلوک است. ، یا به عبارت دیگر، با دو برابر شدن اندازه بلوک، هر بار یک بیت رشد می کند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "we want is to collect together all of those positions, the positions of the bits that are turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. ",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "واقعیت مرتبط در اینجا این است که آن اطلاعات به طور مستقیم با میزان افزونگی مورد نیاز ما مطابقت دارد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -672,7 +672,7 @@
   "end": 716.06
  },
  {
-  "input": "That's really what runs against most people's knee-jerk reaction when they first think about making a message resilient to errors, where usually copying the whole message is the first instinct that comes to mind. ",
+  "input": "That's really what runs against most people's knee-jerk reaction when they first think about making a message resilient to errors, where usually copying the whole message is the first instinct that comes to mind.",
   "translatedText": "این واقعاً چیزی است که در برابر واکنش تند و تیز اکثر افراد زمانی که برای اولین بار در مورد ایجاد یک پیام مقاوم در برابر خطاها فکر می کنند، مخالف است، جایی که معمولاً کپی کردن کل پیام اولین غریزی است که به ذهن می رسد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix. ",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "و بعد، اتفاقاً، این راه کاملاً وجود دارد که گاهی اوقات کدهای همینگ را مشاهده می کنید که در آن پیام را در یک ماتریس بزرگ ضرب می کنید. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -688,7 +688,7 @@
   "end": 734.0
  },
  {
-  "input": "It's kind of nice because it relates it to the broader family of linear codes, but I think that gives almost no intuition for where it comes from or how it scales. ",
+  "input": "It's kind of nice because it relates it to the broader family of linear codes, but I think that gives almost no intuition for where it comes from or how it scales.",
   "translatedText": "به نوعی خوب است زیرا آن را به خانواده گسترده‌تر کدهای خطی مرتبط می‌کند، اما من فکر می‌کنم که تقریباً هیچ شهودی برای اینکه از کجا آمده یا چگونه مقیاس می‌شود، نمی‌دهد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. ",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "و در مورد مقیاس بندی، ممکن است متوجه شوید که با افزایش اندازه بلوک، کارایی این طرح بهتر می شود. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "looks like if we do this on our random block of 16 bits, it returns 9, which has the binary representation 1001. We won't do it here, but you could write a function wh ",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "به عنوان مثال، ما دیدیم که با 256 بیت، شما فقط از 3٪ از آن فضا برای افزونگی استفاده می کنید، و از آنجا به بعد بهتر می شود. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ere the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a state where running th ",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "همانطور که تعداد بیت های برابری یکی یکی افزایش می یابد، اندازه بلوک دو برابر می شود. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits. ",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "و اگر آن را به حد افراط برسانید، می‌توانید بلوکی با مثلاً یک میلیون بیت داشته باشید، که در آن به معنای واقعی کلمه 20 سؤال را با بررسی‌های برابری خود بازی می‌کنید و فقط از 21 بیت برابری استفاده می‌کند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -728,7 +728,7 @@
   "end": 780.02
  },
  {
-  "input": "And if you step back to think about looking at a million bits and locating a single error, that genuinely feels crazy. ",
+  "input": "And if you step back to think about looking at a million bits and locating a single error, that genuinely feels crazy.",
   "translatedText": "و اگر به عقب برگردید و به یک میلیون بیت نگاه کنید و یک خطا را پیدا کنید، واقعاً دیوانه کننده است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that. ",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "البته مشکل این است که با یک بلوک بزرگتر، احتمال مشاهده خطاهای بیش از یک یا دو بیت بالا می رود و کدهای همینگ چیزی فراتر از آن را کنترل نمی کنند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -744,7 +744,7 @@
   "end": 797.66
  },
  {
-  "input": "So in practice, what you'd want is to find the right size so that the probability of too many bit flips isn't too high. ",
+  "input": "So in practice, what you'd want is to find the right size so that the probability of too many bit flips isn't too high.",
   "translatedText": "بنابراین در عمل، چیزی که می خواهید این است که اندازه مناسب را پیدا کنید تا احتمال تلنگرهای بیش از حد بیت خیلی زیاد نباشد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -752,7 +752,7 @@
   "end": 804.3
  },
  {
-  "input": "imulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the positio ",
+  "input": "Also, in practice, errors tend to come in little bursts, which would totally ruin a single block, so one common tactic to help spread out a burst of errors across many different blocks is to interlace those blocks, like this, before they're sent out or stored.",
   "translatedText": "همچنین، در عمل، خطاها معمولاً به صورت پشت سر هم ظاهر می‌شوند، که یک بلوک را کاملاً خراب می‌کند، بنابراین یک تاکتیک رایج برای کمک به گسترش خطاها در بسیاری از بلوک‌های مختلف این است که آن بلوک‌ها، مانند این، قبل از اینکه به هم بریزند ارسال یا ذخیره می شود. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -760,7 +760,7 @@
   "end": 820.98
  },
  {
-  "input": "Then again, a lot of this is rendered completely moot by more modern codes, like the much more commonly used Reed-Solomon algorithm, which handles burst errors particularly well, and it can be tuned to be resilient to a larger number of errors per block. ",
+  "input": "Then again, a lot of this is rendered completely moot by more modern codes, like the much more commonly used Reed-Solomon algorithm, which handles burst errors particularly well, and it can be tuned to be resilient to a larger number of errors per block.",
   "translatedText": "سپس، بسیاری از این موارد به‌طور کامل توسط کدهای مدرن‌تر ارائه می‌شوند، مانند الگوریتم بسیار رایج‌تر Reed-Solomon، که به‌خوبی خطاهای انفجاری را مدیریت می‌کند، و می‌توان آن را به گونه‌ای تنظیم کرد که در برابر تعداد بیشتری از خطاها در هر بلوک انعطاف‌پذیر باشد. . ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "But that's a topic for another time. ",
+  "input": "But that's a topic for another time.",
   "translatedText": "اما این موضوع برای زمان دیگری است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was. ",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "هامینگ در کتاب خود به نام هنر انجام علم و مهندسی به طرز شگفت انگیزی در مورد اینکه کشف این رمز چقدر پر پیچ و خم بود، صریح است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -784,7 +784,7 @@
   "end": 849.94
  },
  {
-  "input": "He first tried all sorts of different schemes involving organizing the bits into parts of a higher dimensional lattice and strange things like this. ",
+  "input": "He first tried all sorts of different schemes involving organizing the bits into parts of a higher dimensional lattice and strange things like this.",
   "translatedText": "او ابتدا انواع طرح‌های مختلف را امتحان کرد که شامل سازماندهی بیت‌ها در بخش‌هایی از شبکه‌ای با ابعاد بالاتر و چیزهای عجیبی مانند این بود. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -792,7 +792,7 @@
   "end": 857.78
  },
  {
-  "input": "The idea that it might be possible to get parity checks to conspire in a way that spells out the position of an error only came to Hamming when he stepped back after a bunch of other analysis and asked, okay, what is the most efficient I could conceivably be about this? ",
+  "input": "The idea that it might be possible to get parity checks to conspire in a way that spells out the position of an error only came to Hamming when he stepped back after a bunch of other analysis and asked, okay, what is the most efficient I could conceivably be about this?",
   "translatedText": "این ایده که ممکن است بررسی‌های برابری به گونه‌ای توطئه شود که موقعیت خطا را مشخص کند، تنها زمانی به ذهن همینگ رسید که او پس از یک سری تحلیل دیگر عقب‌نشینی کرد و پرسید، بسیار خوب، کارآمدترین کاری که می‌توانم داشتم چیست؟ ممکن است در مورد این باشد؟ او همچنین در مورد اینکه چقدر مهم است که چک‌های برابری در ذهنش بود، که در دهه ۱۹۴۰ بسیار کمتر از امروز رایج بود، صادق بود. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -800,7 +800,7 @@
   "end": 871.52
  },
  {
-  "input": "He was also candid about how important it was that parity checks were already on his mind, which would have been way less common back in the 1940s than it is today. ",
+  "input": "He was also candid about how important it was that parity checks were already on his mind, which would have been way less common back in the 1940s than it is today.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "is perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it ",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "در سراسر این کتاب تقریباً دوازده بار است که او به نقل قول لویی پاستور اشاره می کند، شانس به نفع ذهن آماده است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -816,7 +816,7 @@
   "end": 888.22
  },
  {
-  "input": "Clever ideas often look deceptively simple in hindsight, which makes them easy to underappreciate. ",
+  "input": "Clever ideas often look deceptively simple in hindsight, which makes them easy to underappreciate.",
   "translatedText": "ایده‌های هوشمندانه اغلب در آینده به طرز فریبنده‌ای ساده به نظر می‌رسند، که باعث می‌شود به راحتی از آنها قدردانی نشوند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -824,7 +824,7 @@
   "end": 894.3
  },
  {
-  "input": "Right now my honest hope is that Hamming codes, or at least the possibility of such codes, feels almost obvious to you. ",
+  "input": "Right now my honest hope is that Hamming codes, or at least the possibility of such codes, feels almost obvious to you.",
   "translatedText": "در حال حاضر امید صادقانه من این است که کدهای Hamming یا حداقل امکان چنین کدهایی برای شما تقریباً واضح است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't. ",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "اما نباید خودتان را گول بزنید که فکر کنید آنها در واقع واضح هستند، زیرا قطعاً اینطور نیستند. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -840,7 +840,7 @@
   "end": 906.82
  },
  {
-  "input": ", with four yes or no questions, we have 16 possible outcomes for our parity checks, and at first that feels perfect for pinpointing 1 out of 16 positions in the block, but you also need to communicate a 17th outcome, the no error condition. The first one is easiest to actually do by hand, and I think it does a better job instilling the core intuition underlying all of this, ",
+  "input": "Part of the reason that clever ideas look deceptively easy is that we only ever see the final result, cleaning up what was messy, never mentioning all of the wrong turns, underselling just how vast the space of explorable possibilities is at the start of a problem solving process, all of that.",
   "translatedText": "بخشی از دلیل اینکه ایده‌های هوشمندانه به طرز فریبنده‌ای آسان به نظر می‌رسند این است که ما فقط نتیجه نهایی را می‌بینیم، تمیز کردن چیزهایی که به هم ریخته بود، هرگز به همه چرخش‌های اشتباه اشاره نمی‌کنیم، و کم‌فروش بودن فضای احتمالات قابل کشف در ابتدای یک مشکل را کم می‌کنیم. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -848,7 +848,7 @@
   "end": 922.86
  },
  {
-  "input": "which is that the information required to locate a single error is relat ",
+  "input": "But this is true in general.",
   "translatedText": "فرآیند حل، همه اینها اما این به طور کلی درست است. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -856,7 +856,7 @@
   "end": 924.9
  },
  {
-  "input": "ed to the log of the size of the block, or in other words, it grows one bit at a time as the block size doubles. The relevant fact here i ",
+  "input": "I think for some special inventions, there's a second, deeper reason that we underappreciate them.",
   "translatedText": "من فکر می کنم برای برخی اختراعات خاص، دلیل دوم و عمیق تری وجود دارد که ما از آنها قدردانی نمی کنیم. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -864,7 +864,7 @@
   "end": 930.04
  },
  {
-  "input": "Thinking of information in terms of bits had only really coalesced into a full theory by 1948, with Claude Shannon's seminal paper on information theory. ",
+  "input": "Thinking of information in terms of bits had only really coalesced into a full theory by 1948, with Claude Shannon's seminal paper on information theory.",
   "translatedText": "اندیشیدن به اطلاعات بر حسب بیت، تنها در سال 1948 با مقاله اصلی کلود شانون در مورد نظریه اطلاعات، در یک نظریه کامل ادغام شد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -872,7 +872,7 @@
   "end": 938.64
  },
  {
-  "input": "block is even, just like a normal parity check. Now, if there's a single bit error, then ",
+  "input": "This was essentially concurrent with when Hamming developed his algorithm.",
   "translatedText": "این اساساً با زمانی که هامینگ الگوریتم خود را توسعه داد همزمان بود. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "the parity of the full block toggles to be odd, but we would catch that anyway thanks to the four error-correcting checks. However, if there's two errors, then the overall parity is going to toggle back to be And then, by the way, there is this whole other way that you s ",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "این همان مقاله بنیادی بود که نشان داد، به معنای خاصی، تصحیح خطای کارآمد همیشه امکان پذیر است، مهم نیست که احتمال تلنگر بیت چقدر بالا باشد، حداقل در تئوری. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -888,7 +888,7 @@
   "end": 952.9
  },
  {
-  "input": "Shannon and Hamming, by the way, shared an office in Bell Labs, despite working on very different things, which hardly seems coincidental here. ",
+  "input": "Shannon and Hamming, by the way, shared an office in Bell Labs, despite working on very different things, which hardly seems coincidental here.",
   "translatedText": "به هر حال، شانون و همینگ، علیرغم کار بر روی چیزهای بسیار متفاوت، دفتری در آزمایشگاه بل مشترک داشتند، که در اینجا به سختی تصادفی به نظر می رسد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "multiply the message by one big matrix. It's kind of nice because it relates it to the broader family of linear codes, but I think that gives almost no intuition for where it comes from or how it scales. ",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "چندین دهه به سرعت به جلو، و این روزها، بسیاری از ما چنان غرق در فکر کردن در مورد بیت ها و اطلاعات هستیم که به راحتی می توان از تفاوت این طرز تفکر چشم پوشی کرد. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -904,7 +904,7 @@
   "end": 972.34
  },
  {
-  "input": "Ironically, the ideas that most profoundly shape the ways that a future generation thinks will end up looking to that future generation simpler than they really are. ",
+  "input": "Ironically, the ideas that most profoundly shape the ways that a future generation thinks will end up looking to that future generation simpler than they really are.",
   "translatedText": "از قضا، ایده‌هایی که عمیق‌ترین روش‌هایی را که یک نسل آینده فکر می‌کند شکل می‌دهند، در نهایت به آن نسل آینده ساده‌تر از آنچه واقعا هستند نگاه می‌کنند. ",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/portuguese/sentence_translations.json b/2020/hamming-codes-2/portuguese/sentence_translations.json
index 4ef7d5ecd..83676b7b0 100644
--- a/2020/hamming-codes-2/portuguese/sentence_translations.json
+++ b/2020/hamming-codes-2/portuguese/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "Estávamos falando sobre códigos de Hamming, uma forma de criar um bloco de dados onde a maioria dos bits carrega uma mensagem significativa, enquanto alguns outros atuam como uma espécie de redundância, de tal forma que se algum bit for invertido, será uma mensagem bit ou bit de redundância, qualquer coisa neste bloco, um receptor será capaz de identificar que houve um erro e como corrigi-lo.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "A ideia básica apresentada foi como usar múltiplas verificações de paridade para pesquisar binariamente até o erro.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "Por exemplo, o número 7 em binário se parece com 0111, significando essencialmente que é 4 mais 2 mais 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "E observe onde fica a posição 7, ela afeta o primeiro de nossos grupos de paridade, e o segundo, e o terceiro, mas não o último.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "Portanto, ler os resultados dessas quatro verificações de baixo para cima realmente explica a posição do erro.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "Ao colocarmos esses rótulos binários de volta em suas caixas, deixe-me enfatizar que eles são distintos dos dados que estão sendo realmente enviados.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "Eles nada mais são do que um rótulo conceitual para ajudar você e eu a entender de onde vieram os quatro grupos de paridade.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "A elegância de ter tudo o que estamos vendo descrito em binário talvez seja prejudicada pela confusão de ter tudo o que estamos vendo descrito em binário.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "O que obtemos é o primeiro dos nossos quatro grupos de paridade, o que significa que você pode interpretar essa primeira verificação como uma pergunta: ei, se houver um erro, o bit final na posição desse erro é 1?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "E assim por diante.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "A primeira é como generalizar sistematicamente para tamanhos de bloco maiores que sejam potências de dois.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "O que isso significa é que cada um desses bits de paridade está dentro de um e apenas um dos quatro grupos de paridade.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "Quando você pega o XOR de dois bits, ele retornará 1 se um desses bits estiver ativado, mas não se ambos estiverem ativados ou desativados.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "Em outras palavras, é a paridade desses dois bits.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "É como uma adição, mas onde você nunca carrega.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "O ponto principal para você e para mim é que obter o XOR de muitas cadeias de bits diferentes é efetivamente uma maneira de calcular as paródias de vários grupos separados, como acontece com as colunas, tudo de uma só vez.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "Isso nos dá uma maneira bastante elegante de pensar sobre as múltiplas verificações de paridade de nosso algoritmo de código de Hamming como sendo todas agrupadas em uma única operação.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "Isso faz sentido?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "Da mesma forma, a próxima coluna conta quantas posições estão no segundo grupo de paridade, as posições cujo penúltimo bit é 1, e que também estão destacadas, e assim por diante.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "Agora, uma vez que temos isto, isto dá-nos uma maneira muito boa de pensar sobre porque é que estes quatro bits resultantes na parte inferior indicam diretamente a posição de um erro.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "Digamos que algum bit neste bloco seja alternado de 0 para 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "O que isso significa é que a posição desse bit agora será incluída no XOR total, o que muda a soma de 0 para esse valor recém-incluído, a posição do erro.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "Começaremos criando um array aleatório de 16 1s e 0s para simular o bloco de dados, e darei a ele o nome de bits, mas é claro que na prática isso seria algo que receberíamos de um remetente e, em vez de sendo aleatório, carregaria 11 bits de dados junto com 5 bits de paridade.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "Então, se criarmos uma lista que percorre todos esses pares, pares que se parecem com i, e então extrairmos apenas o valor i, apenas o índice, bem, não é tão emocionante, apenas recuperamos esses índices de 0 a 15.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "Mas se adicionarmos a condição de fazer isso apenas se for bit, ou seja, se esse bit for 1 e não 0, bem, então ele retira apenas as posições onde o bit correspondente está ativado.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "Não faremos isso aqui, mas você poderia escrever uma função onde o remetente usa essa representação binária para definir os quatro bits de paridade conforme necessário, levando esse bloco a um estado em que a execução dessa linha de código na lista completa de bits retorna um 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "O que é legal é que se alternarmos qualquer um dos bits desta lista, simulando um erro aleatório de ruído, se você executar essa mesma linha de código, esse erro será impresso.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "Você pode obter esse bloco do nada, executar esta única linha nele e ele exibirá automaticamente a posição de um erro ou um 0, se não houver nenhum.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "Agora, dependendo do seu conforto com binários, XORs e software em geral, você pode achar essa perspectiva um pouco confusa ou muito mais elegante e simples que você está se perguntando por que não começamos com ela desde o início. -ir.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "Falando livremente, a perspectiva de verificação de paridade múltipla é mais fácil de pensar ao implementar códigos de Hamming em hardware de maneira muito direta, e a perspectiva XOR é mais fácil de pensar ao fazê-lo em software, de um nível mais alto.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "O fato relevante aqui é que essa informação corresponde diretamente à quantidade de redundância necessária.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "E então, a propósito, há toda essa outra maneira que às vezes você vê os códigos de Hamming apresentados, onde você multiplica a mensagem por uma grande matriz.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "E por falar em dimensionamento, você deve notar que a eficiência desse esquema só melhora à medida que aumentamos o tamanho do bloco.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "Por exemplo, vimos que com 256 bits, você está usando apenas 3% desse espaço para redundância, e isso continua melhorando a partir daí.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "À medida que o número de bits de paridade aumenta um por um, o tamanho do bloco continua duplicando.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "E se você levar isso ao extremo, você poderia ter um bloco com, digamos, um milhão de bits, onde você estaria literalmente jogando 20 perguntas com suas verificações de paridade, e ele usaria apenas 21 bits de paridade.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "O problema, claro, é que com um bloco maior, a probabilidade de ver mais de um ou dois erros de bit aumenta, e os códigos de Hamming não lidam com nada além disso.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "Mas isso é assunto para outra hora.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "Em seu livro The Art of Doing Science and Engineering, Hamming é maravilhosamente sincero sobre o quão sinuosa foi sua descoberta desse código.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "Há cerca de meia dúzia de vezes ao longo deste livro que ele faz referência à citação de Louis Pasteur: a sorte favorece uma mente preparada.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "Mas você não deve se enganar pensando que eles são realmente óbvios, porque definitivamente não são.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "Este foi o mesmo artigo fundamental que mostrou, em certo sentido, que a correção eficiente de erros é sempre possível, não importa quão alta seja a probabilidade de inversões de bits, pelo menos em teoria.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "Avançando várias décadas, hoje em dia muitos de nós estamos tão imersos em pensar sobre bits e informações que é fácil ignorar o quão distinta era essa forma de pensar.",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/russian/sentence_translations.json b/2020/hamming-codes-2/russian/sentence_translations.json
index e4436539b..3c8e6690d 100644
--- a/2020/hamming-codes-2/russian/sentence_translations.json
+++ b/2020/hamming-codes-2/russian/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "Мы говорили о кодах Хэмминга, способе создания блока данных, в котором большинство битов несут значимое сообщение, а несколько других действуют как своего рода избыточность, таким образом, что если какой-либо бит переворачивается, либо сообщение бит или бит избыточности, что-либо в этом блоке, получатель сможет определить, что произошла ошибка и как ее исправить.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "Основная идея, представленная там, заключалась в том, как использовать несколько проверок четности для двоичного поиска пути к ошибке.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "Например, число 7 в двоичном формате выглядит как 0111, что, по сути, означает, что это 4 плюс 2 плюс 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "И обратите внимание, где находится позиция 7: она влияет и на первую из наших групп четности, и на вторую, и на третью, но не на последнюю.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "Таким образом, чтение результатов этих четырех проверок снизу вверх действительно определяет положение ошибки.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "Размещая эти двоичные метки обратно в коробки, позвольте мне подчеркнуть, что они отличаются от фактически отправляемых данных.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "Это не что иное, как концептуальный ярлык, который поможет вам и мне понять, откуда взялись четыре группы паритета.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "Элегантность того, что все, на что мы смотрим, описывается в двоичном формате, возможно, подрывается путаницей, связанной с тем, что все, на что мы смотрим, описывается в двоичном формате.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "То, что мы получаем, — это первая из наших четырех групп четности, что означает, что вы можете интерпретировать эту первую проверку как вопрос: «Эй, если есть ошибка, последний бит в позиции этой ошибки равен 1?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "» И так далее.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "Во-первых, как систематически обобщать размеры блоков, превышающие степени двойки.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "Это означает, что каждый из этих битов четности находится внутри одной и только одной из четырех групп четности.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "Когда вы выполняете операцию XOR двух битов, она возвращает 1, если один из этих битов включен, но не если оба включены или выключены.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "Другими словами, это четность этих двух битов.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "Это как дополнение, но куда не понесешь.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "Ключевым моментом для нас с вами является то, что выполнение XOR множества различных битовых строк фактически является способом вычислить пародии на кучу отдельных групп, как это происходит со столбцами, одним махом.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "Это дает нам довольно привлекательный способ представить множественные проверки четности нашего алгоритма кода Хэмминга как объединенные в одну операцию.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "Имеет ли это смысл?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "Аналогично, в следующем столбце подсчитывается количество позиций во второй группе четности, позиций, предпоследний бит которых равен 1, которые также выделены и т. д.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "Теперь, когда у нас это получилось, это дает нам действительно хороший способ задуматься о том, почему эти четыре результирующих бита внизу непосредственно определяют положение ошибки.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "Допустим, какой-то бит в этом блоке переключается с 0 на 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "Это означает, что позиция этого бита теперь будет включена в общее исключающее ИЛИ, что изменит сумму с 0 на новое включенное значение, позицию ошибки.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "Мы начнем с создания случайного массива из 16 единиц и нулей для имитации блока данных, и я дам ему биты имени, но, конечно, на практике это будет то, что мы получаем от отправителя, и вместо будучи случайным, он будет нести 11 бит данных вместе с 5 битами четности.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "Итак, если мы затем создадим список, который будет циклически перебирать все эти пары, пары, которые выглядят как i, а затем мы вытащим только значение i, только индекс, ну, это не так уж и интересно, мы просто вернем эти индексы от 0 до 15.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "Но если мы добавим условие делать это только в том случае, если бит, то есть, если этот бит равен 1, а не 0, то тогда будут выбраны только те позиции, где включен соответствующий бит.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "Мы не будем этого делать здесь, но вы можете написать функцию, в которой отправитель использует это двоичное представление для установки четырех битов четности по мере необходимости, в конечном итоге переводя этот блок в состояние, при котором выполнение этой строки кода для полного списка бит возвращает результат. 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "Что круто, так это то, что если мы переключим любой из битов в этом списке, имитируя случайную ошибку из-за шума, то если вы запустите ту же строку кода, она выведет эту ошибку.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "Вы можете получить этот блок из ниоткуда, запустить к нему эту единственную строку, и он автоматически выдаст позицию ошибки или 0, если ее не было.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "Теперь, в зависимости от вашего опыта работы с двоичными файлами, операциями XOR и программным обеспечением в целом, вы можете найти эту точку зрения либо немного запутанной, либо настолько более элегантной и простой, что вы задаетесь вопросом, почему мы просто не начали с нее с самого начала. -идти.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "Грубо говоря, о перспективе множественной проверки четности легче думать при прямой реализации кодов Хэмминга в аппаратном обеспечении, а о перспективе XOR легче всего думать, когда она выполняется в программном обеспечении, на более высоком уровне.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "Важным фактом здесь является то, что эта информация напрямую соответствует тому, какая избыточность нам нужна.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "И, кстати, есть совершенно другой способ представления кодов Хэмминга: вы умножаете сообщение на одну большую матрицу.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "Говоря о масштабировании, вы можете заметить, что эффективность этой схемы становится только выше по мере увеличения размера блока.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "Например, мы увидели, что при 256 битах вы используете только 3% этого пространства для избыточности, и с этого момента ситуация становится все лучше.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "По мере того как количество битов четности увеличивается один за другим, размер блока продолжает удваиваться.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "А если довести это до крайности, то у вас может получиться блок, скажем, в миллион битов, в котором вы буквально будете разыгрывать 20 вопросов с проверками на четность, и он использует только 21 бит четности.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "Проблема, конечно, в том, что при увеличении блока вероятность увидеть более одного или двух битовых ошибок возрастает, а коды Хэмминга ничего сверх этого не обрабатывают.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "Но это тема для другого раза.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "В своей книге «Искусство заниматься наукой и инженерией» Хэмминг удивительно откровенно рассказывает о том, насколько запутанным было его открытие этого кода.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "В этой книге он примерно полдюжины раз ссылается на цитату Луи Пастера: удача любит подготовленный ум.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "Но не стоит обманывать себя, думая, что они на самом деле очевидны, потому что это определенно не так.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "Это была та же основополагающая статья, которая в определенном смысле показала, что эффективное исправление ошибок всегда возможно, независимо от того, насколько высока вероятность переворота битов, по крайней мере теоретически.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "Перенесемся на несколько десятилетий вперед, и в наши дни многие из нас настолько погружены в размышления о битах и информации, что легко упустить из виду, насколько особенным был этот образ мышления.",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/spanish/sentence_translations.json b/2020/hamming-codes-2/spanish/sentence_translations.json
index 2cf2f48d9..2e1d815fe 100644
--- a/2020/hamming-codes-2/spanish/sentence_translations.json
+++ b/2020/hamming-codes-2/spanish/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "Estábamos hablando de códigos Hamming, una forma de crear un bloque de datos donde la mayoría de los bits llevan un mensaje significativo, mientras que algunos otros actúan como una especie de redundancia, de tal manera que si se voltea algún bit, ya sea un mensaje bit o un bit de redundancia, cualquier cosa en este bloque, un receptor podrá identificar que hubo un error y cómo solucionarlo.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "La idea básica presentada allí fue cómo utilizar múltiples comprobaciones de paridad para realizar una búsqueda binaria hasta llegar al error.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "Por ejemplo, el número 7 en binario se parece a 0111, lo que básicamente dice que es 4 más 2 más 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "Y observen dónde se ubica la posición 7, afecta al primero de nuestros grupos de paridad, al segundo y al tercero, pero no al último.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "Entonces, leer los resultados de esas cuatro comprobaciones de abajo hacia arriba sí explica la posición del error.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "Mientras volvemos a colocar estas etiquetas binarias en sus cajas, permítanme enfatizar que son distintas de los datos que realmente se envían.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "No son más que una etiqueta conceptual para ayudarnos a usted y a mí a comprender de dónde provienen los cuatro grupos de paridad.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "La elegancia de que todo lo que estamos viendo se describa en binario tal vez se vea socavada por la confusión de que todo lo que estamos viendo se describa en binario.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "Lo que obtenemos es el primero de nuestros cuatro grupos de paridad, lo que significa que puedes interpretar esa primera verificación como si preguntaras, oye, si hay un error, ¿el último bit en la posición de ese error es 1?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "Etcétera.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "La primera es cómo generalizar sistemáticamente a tamaños de bloques que son potencias de dos mayores.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "Lo que eso significa es que cada uno de esos bits de paridad se encuentra dentro de uno y sólo uno de los cuatro grupos de paridad.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "Cuando tomas el XOR de dos bits, devolverá un 1 si cualquiera de esos bits está activado, pero no si ambos están activados o desactivados.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "Dicho de otra manera, es la paridad de estos dos bits.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "Es como una suma, pero donde nunca se lleva.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "El punto clave para usted y para mí es que tomar el XOR de muchas cadenas de bits diferentes es efectivamente una forma de calcular las parodias de un grupo de grupos separados, como ocurre con las columnas, todo de una sola vez.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "Esto nos da una forma bastante elegante de pensar en las múltiples comprobaciones de paridad de nuestro algoritmo de código Hamming como si estuvieran todas empaquetadas en una sola operación.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "¿Tiene sentido?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "Asimismo, la siguiente columna cuenta cuántas posiciones hay en el segundo grupo de paridad, las posiciones cuyo penúltimo bit es un 1, y cuáles también están resaltadas, y así sucesivamente.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "Ahora, una vez que lo tenemos así, nos da una muy buena manera de pensar por qué estos cuatro bits resultantes en la parte inferior explican directamente la posición de un error.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "Digamos que una parte de este bloque se cambia de 0 a 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "Lo que eso significa es que la posición de ese bit ahora se incluirá en el XOR total, lo que cambia la suma de 0 a ser este valor recién incluido, la posición del error.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "Comenzaremos creando una matriz aleatoria de 16 1 y 0 para simular el bloque de datos, y le daré el nombre de bits, pero, por supuesto, en la práctica esto sería algo que recibiríamos de un remitente, y en lugar de al ser aleatorio, transportaría 11 bits de datos junto con 5 bits de paridad.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "Entonces, si luego creamos una lista que recorre todos estos pares, pares que se parecen a i, y luego extraemos solo el valor de i, solo el índice, bueno, no es tan emocionante, simplemente recuperamos esos índices del 0 al 15.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "Pero si agregamos la condición de hacer esto solo si el bit, es decir, si ese bit es un 1 y no un 0, entonces extrae solo las posiciones donde el bit correspondiente está activado.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "No lo haremos aquí, pero podría escribir una función en la que el remitente use esa representación binaria para establecer los cuatro bits de paridad según sea necesario y, en última instancia, llevar este bloque a un estado en el que la ejecución de esta línea de código en la lista completa de bits devuelva un 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "Lo bueno es que si alternamos cualquiera de los bits en esta lista, simulando un error aleatorio debido al ruido, si ejecuta esta misma línea de código, imprimirá ese error.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "Podrías obtener este bloque de la nada, ejecutar esta única línea en él y automáticamente mostrará la posición de un error, o un 0 si no hubo ninguno.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "Ahora, dependiendo de su comodidad con los binarios, los XOR y el software en general, puede encontrar esta perspectiva un poco confusa o mucho más elegante y simple que se pregunte por qué no comenzamos con ella desde el principio. -ir.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "En términos generales, es más fácil pensar en la perspectiva de verificación de paridad múltiple cuando se implementan códigos Hamming en hardware de manera muy directa, y es más fácil pensar en la perspectiva XOR cuando se hace en software, desde un nivel superior.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "El hecho relevante aquí es que esa información corresponde directamente a cuánta redundancia necesitamos.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "Y luego, por cierto, existe otra forma completamente distinta en la que a veces se presentan los códigos Hamming, donde se multiplica el mensaje por una gran matriz.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "Y hablando de escalamiento, es posible que notes que la eficiencia de este esquema solo mejora a medida que aumentamos el tamaño del bloque.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "Por ejemplo, vimos que con 256 bits, se utiliza solo el 3% de ese espacio para redundancia, y a partir de ahí sigue mejorando.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "A medida que el número de bits de paridad crece uno por uno, el tamaño del bloque se sigue duplicando.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "Y si lleva eso al extremo, podría tener un bloque con, digamos, un millón de bits, donde literalmente estaría jugando 20 preguntas con sus comprobaciones de paridad, y utiliza sólo 21 bits de paridad.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "El problema, por supuesto, es que con un bloque más grande, la probabilidad de ver más de uno o dos errores de bit aumenta, y los códigos Hamming no manejan nada más allá de eso.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "Pero ese es un tema para otro momento.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "En su libro El arte de hacer ciencia e ingeniería, Hamming es maravillosamente sincero acerca de cuán sinuoso fue su descubrimiento de este código.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "Hay como media docena de veces a lo largo de este libro en las que hace referencia a la cita de Louis Pasteur: La suerte favorece a una mente preparada.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "Pero no deberías engañarte pensando que en realidad son obvios, porque definitivamente no lo son.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "Este fue el mismo artículo fundamental que demostró, en cierto sentido, que siempre es posible una corrección de errores eficiente, sin importar cuán alta sea la probabilidad de que se produzcan cambios de bit, al menos en teoría.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "Varias décadas después, hoy en día muchos de nosotros estamos tan inmersos en pensar en bits e información que es fácil pasar por alto cuán distinta era esta forma de pensar.",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/tamil/sentence_translations.json b/2020/hamming-codes-2/tamil/sentence_translations.json
index 7beb32dbf..d28b1aa4f 100644
--- a/2020/hamming-codes-2/tamil/sentence_translations.json
+++ b/2020/hamming-codes-2/tamil/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "நாங்கள் ஹேமிங் குறியீடுகளைப் பற்றி பேசிக் கொண்டிருந்தோம், பெரும்பாலான பிட்கள் அர்த்தமுள்ள செய்தியைக் கொண்டு செல்லும் தரவுத் தொகுதியை உருவாக்கும் ஒரு வழி பிட் அல்லது ஒரு பணிநீக்கம் பிட், இந்த பிளாக்கில் உள்ள எதையும், ஒரு பெறுநரால் பிழை இருப்பதை அடையாளம் காண முடியும், அதை எவ்வாறு சரிசெய்வது.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "அங்கு வழங்கப்பட்ட அடிப்படை யோசனையானது, பிழைக்கான உங்கள் வழியை பைனரி தேடுவதற்கு பல சமநிலை சரிபார்ப்புகளை எவ்வாறு பயன்படுத்துவது என்பதுதான்.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "எடுத்துக்காட்டாக, பைனரியில் உள்ள எண் 7 0111 போல் தெரிகிறது, இது 4 கூட்டல் 2 கூட்டல் 1 என்று கூறுகிறது.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "மற்றும் நிலை 7 எங்கு அமர்ந்திருக்கிறது என்பதைக் கவனியுங்கள், இது எங்கள் சமத்துவக் குழுக்களில் முதலாவது மற்றும் இரண்டாவது மற்றும் மூன்றாவது, ஆனால் கடைசியாக அல்ல.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "எனவே அந்த நான்கு காசோலைகளின் முடிவுகளை கீழிருந்து மேல் வரை படிப்பது பிழையின் நிலையை வெளிப்படுத்துகிறது.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "இந்த பைனரி லேபிள்களை அவற்றின் பெட்டிகளில் மீண்டும் வைக்கும்போது, அவை உண்மையில் அனுப்பப்படும் தரவுகளிலிருந்து வேறுபட்டவை என்பதை வலியுறுத்துகிறேன்.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "நான்கு சமத்துவக் குழுக்கள் எங்கிருந்து வந்தன என்பதைப் புரிந்துகொள்ள உங்களுக்கும் எனக்கும் உதவும் ஒரு கருத்தியல் லேபிளைத் தவிர வேறொன்றுமில்லை.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "நாம் பார்க்கும் அனைத்தும் பைனரியில் விவரிக்கப்படுவதன் நேர்த்தியானது, நாம் பார்க்கும் அனைத்தும் பைனரியில் விவரிக்கப்பட வேண்டும் என்ற குழப்பத்தால் குறைக்கப்படலாம்.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "நாங்கள் பெறுவது எங்களின் நான்கு சமத்துவக் குழுக்களில் முதன்மையானது, அதாவது அந்த முதல் காசோலையைக் கேட்பது போல் நீங்கள் விளக்கலாம், ஏய், பிழை இருந்தால், அந்த பிழையின் நிலையில் இறுதி பிட் 1 உள்ளதா?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "மற்றும் பல.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "முதலாவதாக, இரண்டின் பெரிய சக்திகளைக் கொண்ட தொகுதி அளவுகளை முறையாகப் பொதுமைப்படுத்துவது எப்படி.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "இதன் பொருள் என்னவென்றால், அந்த ஒவ்வொரு பாரிட்டி பிட்களும் ஒன்றுக்குள் அமர்ந்து நான்கு சமத்துவக் குழுக்களில் ஒன்று மட்டுமே.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "நீங்கள் இரண்டு பிட்களின் XOR ஐ எடுக்கும்போது, அந்த பிட்களில் ஏதேனும் ஒன்று இயக்கப்பட்டிருந்தால் அது 1ஐத் தரும், ஆனால் இரண்டும் ஆன் அல்லது ஆஃப் செய்யப்பட்டிருந்தால் அல்ல.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "வித்தியாசமாக சொற்றொடர், இந்த இரண்டு பிட்களின் சமநிலை.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "இது கூட்டல் போன்றது, ஆனால் நீங்கள் எடுத்துச் செல்லவே இல்லை.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "உங்களுக்கும் எனக்கும் முக்கியமான விஷயம் என்னவென்றால், பல வேறுபட்ட பிட் சரங்களின் XORஐ எடுத்துக்கொள்வது, தனித்தனி குழுக்களின் கேலிக்கூத்துகளை கணக்கிடுவதற்கான ஒரு வழியாகும்.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "எங்கள் ஹேமிங் குறியீடு அல்காரிதத்தில் இருந்து பல சமநிலை சரிபார்ப்புகளைப் பற்றி சிந்திக்க இது எங்களுக்கு மிகவும் எளிமையான வழியை வழங்குகிறது, ஏனெனில் அனைத்தும் ஒன்றாக ஒரே செயல்பாட்டில் தொகுக்கப்படுகின்றன.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "அதில் ஏதாவது பொருளிருக்கிறதா? அதில் அர்த்தமிருக்கிறதா?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "அதேபோல, அடுத்த நெடுவரிசை, இரண்டாவது சமத்துவக் குழுவில் எத்தனை நிலைகள் உள்ளன, இரண்டாவது முதல் கடைசி பிட் வரையிலான நிலைகள் 1, மற்றும் அவையும் தனிப்படுத்தப்பட்டவை மற்றும் பலவற்றைக் கணக்கிடுகிறது.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "இப்போது நாம் இதைப் பெற்றவுடன், கீழே உள்ள இந்த நான்கு பிட்கள் ஏன் பிழையின் நிலையை நேரடியாக உச்சரிக்கின்றன என்பதைப் பற்றி சிந்திக்க இது ஒரு நல்ல வழியை வழங்குகிறது.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "இந்த பிளாக்கில் சில பிட்கள் 0 இலிருந்து 1 ஆக மாறுகிறது என்று வைத்துக்கொள்வோம்.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "இதன் பொருள் என்னவென்றால், அந்த பிட்டின் நிலை இப்போது மொத்த XOR இல் சேர்க்கப்படும், இது கூட்டுத்தொகையை 0 என்பதிலிருந்து புதிதாக சேர்க்கப்பட்ட இந்த மதிப்பாக மாற்றுகிறது, பிழையின் நிலை.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "தரவுத் தொகுதியை உருவகப்படுத்த 16 1s மற்றும் 0s என்ற சீரற்ற வரிசையை உருவாக்குவதன் மூலம் தொடங்குவோம், நான் அதற்கு பெயர் பிட்களை தருகிறேன், ஆனால் நடைமுறையில் இது ஒரு அனுப்புநரிடமிருந்து நாம் பெறும் ஒன்று, அதற்கு பதிலாக சீரற்றதாக இருந்தால், அது 11 டேட்டா பிட்களையும் 5 பேரிட்டி பிட்களையும் கொண்டு செல்லும்.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "எனவே, இந்த ஜோடிகள் அனைத்தின் மீதும் சுழலும் ஒரு பட்டியலை உருவாக்கினால், i போல தோற்றமளிக்கும் ஜோடிகள், பின்னர் i மதிப்பை, குறியீட்டை மட்டும் வெளியே இழுத்தால், அது அவ்வளவு உற்சாகமாக இல்லை, அந்த குறியீடுகளை 0 முதல் 15 வரை திரும்பப் பெறுவோம்.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "ஆனால் பிட் என்றால் மட்டுமே இதைச் செய்ய வேண்டும் என்ற நிபந்தனையைச் சேர்த்தால், அதாவது அந்த பிட் 1 மற்றும் 0 அல்ல என்றால், அது தொடர்புடைய பிட் இயக்கப்பட்டிருக்கும் நிலைகளை மட்டும் இழுக்கிறது.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "நாங்கள் அதை இங்கே செய்ய மாட்டோம், ஆனால் அனுப்புநர் அந்த பைனரி பிரதிநிதித்துவத்தைப் பயன்படுத்தி நான்கு பேரிட்டி பிட்களை தேவைக்கேற்ப அமைக்கும் ஒரு செயல்பாட்டை நீங்கள் எழுதலாம், இறுதியில் இந்தத் தொகுதியை பிட்களின் முழுப் பட்டியலிலும் இந்த குறியீட்டு வரியை இயக்கும் நிலைக்கு கொண்டு செல்லலாம். ஒரு 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "நல்ல விஷயம் என்னவென்றால், இந்த பட்டியலில் உள்ள பிட்களில் ஏதேனும் ஒன்றை நாம் மாற்றினால், இரைச்சலில் இருந்து ஒரு சீரற்ற பிழையை உருவகப்படுத்தினால், நீங்கள் இதே குறியீட்டை இயக்கினால், அது அந்த பிழையை அச்சிடுகிறது.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "இந்தத் தொகுதியை நீங்கள் நீல நிறத்தில் இருந்து பெறலாம், இந்த ஒற்றை வரியை அதில் இயக்கலாம், மேலும் அது பிழையின் நிலையை தானாகவே துப்பிவிடும், அல்லது எதுவும் இல்லை என்றால் 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "இப்போது, பைனரி மற்றும் XORகள் மற்றும் பொதுவாக மென்பொருளில் உள்ள உங்கள் வசதியைப் பொறுத்து, இந்த முன்னோக்கைக் கொஞ்சம் குழப்பமாகவோ அல்லது மிகவும் நேர்த்தியாகவும் எளிமையாகவும் நாம் ஏன் தொடங்கவில்லை என்று நீங்கள் ஆச்சரியப்படுகிறீர்கள். -போ.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "தளர்வாகச் சொன்னால், வன்பொருளில் ஹேமிங் குறியீடுகளை நேரடியாகச் செயல்படுத்தும் போது, மல்டிபிள் பேரிட்டி காசோலைக் கண்ணோட்டத்தைப் பற்றி சிந்திக்க எளிதானது, மேலும் XOR முன்னோக்கு மென்பொருளில், உயர் மட்டத்தில் இருந்து அதைச் செய்யும்போது சிந்திக்க எளிதானது.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "இங்கே பொருத்தமான உண்மை என்னவென்றால், அந்த தகவல் நமக்கு எவ்வளவு பணிநீக்கம் தேவை என்பதை நேரடியாக ஒத்துள்ளது.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "பின்னர், இந்த முழு வேறு வழியும் உள்ளது, சில சமயங்களில் ஹேமிங் குறியீடுகள் வழங்கப்படுகின்றன, அங்கு நீங்கள் செய்தியை ஒரு பெரிய மேட்ரிக்ஸால் பெருக்குகிறீர்கள்.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "மற்றும் அளவிடுதல் பற்றி பேசுகையில், தொகுதி அளவை அதிகரிக்கும்போது மட்டுமே இந்த திட்டத்தின் செயல்திறன் சிறப்பாக இருக்கும் என்பதை நீங்கள் கவனிக்கலாம்.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "எடுத்துக்காட்டாக, 256 பிட்கள் மூலம், நீங்கள் பணிநீக்கத்திற்கு அந்த இடத்தில் 3% மட்டுமே பயன்படுத்துகிறீர்கள் என்பதை நாங்கள் பார்த்தோம், மேலும் அது அங்கிருந்து சிறப்பாக வருகிறது.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "சமநிலை பிட்களின் எண்ணிக்கை ஒவ்வொன்றாக வளரும்போது, தொகுதி அளவு இரட்டிப்பாகிறது.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "நீங்கள் அதை ஒரு தீவிரத்திற்கு எடுத்துக் கொண்டால், நீங்கள் ஒரு மில்லியன் பிட்கள் கொண்ட ஒரு தொகுதியை வைத்திருக்கலாம், அங்கு நீங்கள் உண்மையில் உங்கள் சமநிலை சரிபார்ப்புகளுடன் 20 கேள்விகளை விளையாடுவீர்கள், மேலும் அது 21 சமநிலை பிட்களை மட்டுமே பயன்படுத்துகிறது.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "பிரச்சனை, நிச்சயமாக, ஒரு பெரிய தொகுதியுடன், ஒன்று அல்லது இரண்டு பிட் பிழைகளை பார்க்கும் நிகழ்தகவு அதிகரிக்கிறது, மேலும் ஹேமிங் குறியீடுகள் அதைத் தாண்டி எதையும் கையாளாது.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "ஆனால் அது மற்றொரு நேரத்திற்கு ஒரு தலைப்பு.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "அவரது தி ஆர்ட் ஆஃப் டூயிங் சயின்ஸ் அண்ட் இன்ஜினியரிங் என்ற புத்தகத்தில், ஹாமிங் இந்த குறியீட்டின் கண்டுபிடிப்பு எவ்வளவு வளைந்திருந்தது என்பதைப் பற்றி அற்புதமாக நேர்மையாக கூறினார்.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "லூயிஸ் பாஸ்டர் மேற்கோள்களை அவர் குறிப்பிடும் இந்த புத்தகம் முழுவதும் அரை டஜன் முறைகள் உள்ளன, அதிர்ஷ்டம் தயாராக இருக்கும் மனதை ஆதரிக்கிறது.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "ஆனால் அவை உண்மையில் வெளிப்படையானவை என்று நினைத்து உங்களை நீங்களே ஏமாற்றிக் கொள்ளக்கூடாது, ஏனென்றால் அவை நிச்சயமாக இல்லை.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "ஒரு குறிப்பிட்ட அர்த்தத்தில், பிட் ஃபிளிப்புகளின் நிகழ்தகவு எவ்வளவு அதிகமாக இருந்தாலும், குறைந்தபட்சம் கோட்பாட்டில், திறமையான பிழை திருத்தம் எப்போதும் சாத்தியமாகும் என்பதைக் காட்டிய அதே அடிப்படைக் கட்டுரை இதுவாகும்.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "பல தசாப்தங்களாக வேகமாக முன்னேறி, இந்த நாட்களில், நம்மில் பலர் பிட்கள் மற்றும் தகவல்களைப் பற்றி சிந்திப்பதில் மூழ்கிவிட்டோம், இந்த சிந்தனை முறை எவ்வளவு வித்தியாசமானது என்பதைக் கவனிப்பது எளிது.",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/telugu/sentence_translations.json b/2020/hamming-codes-2/telugu/sentence_translations.json
index 9ac9a55b3..0bd1a7f40 100644
--- a/2020/hamming-codes-2/telugu/sentence_translations.json
+++ b/2020/hamming-codes-2/telugu/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "మేము హామింగ్ కోడ్‌ల గురించి మాట్లాడుతున్నాము, చాలా బిట్‌లు అర్థవంతమైన సందేశాన్ని కలిగి ఉండే డేటా బ్లాక్‌ను సృష్టించే మార్గం, మరికొన్ని ఒక రకమైన రిడెండెన్సీగా పనిచేస్తాయి, ఆ విధంగా ఏదైనా బిట్ తిప్పబడితే, సందేశం బిట్ లేదా రిడెండెన్సీ బిట్, ఈ బ్లాక్‌లో ఏదైనా, రిసీవర్ లోపం ఉందని మరియు దాన్ని ఎలా పరిష్కరించాలో గుర్తించగలదు.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "బైనరీ శోధన కోసం బహుళ పారిటీ తనిఖీలను ఎలా ఉపయోగించాలి అనేది అక్కడ అందించబడిన ప్రాథమిక ఆలోచన.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "ఉదాహరణకు, బైనరీలో 7 సంఖ్య 0111 లాగా కనిపిస్తుంది, ముఖ్యంగా ఇది 4 ప్లస్ 2 ప్లస్ 1 అని చెబుతోంది.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "మరియు స్థానం 7 ఎక్కడ కూర్చుందో గమనించండి, ఇది మా సమానత్వ సమూహాలలో మొదటిదానిని ప్రభావితం చేస్తుంది మరియు రెండవది మరియు మూడవది, కానీ చివరిది కాదు.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "కాబట్టి ఆ నాలుగు చెక్‌ల ఫలితాలను దిగువ నుండి పైకి చదవడం నిజంగా లోపం యొక్క స్థితిని తెలియజేస్తుంది.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "మేము ఈ బైనరీ లేబుల్‌లను వాటి పెట్టెల్లోకి తిరిగి ఉంచినప్పుడు, అవి వాస్తవానికి పంపబడుతున్న డేటా నుండి విభిన్నంగా ఉన్నాయని నేను నొక్కిచెబుతున్నాను.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "నాలుగు సమానత్వ సమూహాలు ఎక్కడ నుండి వచ్చాయో అర్థం చేసుకోవడంలో మీకు మరియు నాకు సహాయం చేయడానికి అవి సంభావిత లేబుల్ తప్ప మరేమీ కాదు.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "మనం చూస్తున్న ప్రతిదీ బైనరీలో వర్ణించబడటం యొక్క సొగసైనది బహుశా మనం చూస్తున్న ప్రతిదాన్ని బైనరీలో వివరించడం వల్ల కలిగే గందరగోళం వల్ల తగ్గుతుంది.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "మేము పొందేది మా నాలుగు సమానత్వ సమూహాలలో మొదటిది, అంటే మీరు ఆ మొదటి చెక్‌ని అడుగుతున్నట్లు అర్థం చేసుకోవచ్చు, హే, లోపం ఉన్నట్లయితే, ఆ లోపం యొక్క స్థానం 1గా ఉందా?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "మరియు అందువలన న.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "మొదటిది రెండు పెద్ద శక్తులు ఉండే పరిమాణాలను బ్లాక్ చేయడానికి క్రమపద్ధతిలో సాధారణీకరించడం ఎలా.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "దాని అర్థం ఏమిటంటే, ఆ పారిటీ బిట్‌లలో ప్రతి ఒక్కటి నాలుగు సమాన సమూహాలలో ఒకటి మాత్రమే ఉంటుంది.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "మీరు రెండు బిట్‌ల XORను తీసుకున్నప్పుడు, ఆ బిట్‌లలో ఒకదానిని ఆన్ చేసినట్లయితే అది 1ని తిరిగి ఇస్తుంది, కానీ రెండూ ఆన్ లేదా ఆఫ్ చేయబడితే కాదు.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "విభిన్నంగా పదబంధం, ఇది ఈ రెండు బిట్‌ల సమానత్వం.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "ఇది అదనంగా వంటిది, కానీ మీరు ఎక్కడికి తీసుకెళ్లలేరు.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "మీకు మరియు నాకు ముఖ్యమైన అంశం ఏమిటంటే, అనేక విభిన్న బిట్ స్ట్రింగ్‌ల యొక్క XOR తీసుకోవడం అనేది నిలువు వరుసల మాదిరిగానే, ప్రత్యేక సమూహాల యొక్క పేరడీలను గణించడానికి ఒక మార్గం.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "ఇది మా హామింగ్ కోడ్ అల్గారిథమ్ నుండి బహుళ పారిటీ చెక్‌ల గురించి ఆలోచించడానికి చాలా చురుకైన మార్గాన్ని అందిస్తుంది, ఎందుకంటే అన్నీ ఒకే ఆపరేషన్‌లో ప్యాక్ చేయబడతాయి.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "అది సమంజసమా?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "అదేవిధంగా, తదుపరి నిలువు వరుస రెండవ సమాన సమూహంలో ఎన్ని స్థానాలు ఉన్నాయి, రెండవ నుండి చివరి బిట్ 1 వరకు ఉన్న స్థానాలు మరియు హైలైట్ చేయబడినవి మరియు మొదలైనవి కూడా లెక్కించబడతాయి.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "ఇప్పుడు మనం దీన్ని ఇలా కలిగి ఉంటే, దిగువన ఉన్న ఈ నాలుగు ఫలిత బిట్‌లు నేరుగా లోపం యొక్క స్థానాన్ని ఎందుకు వివరిస్తాయి అనే దాని గురించి ఆలోచించడానికి ఇది మాకు నిజంగా మంచి మార్గాన్ని ఇస్తుంది.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "ఈ బ్లాక్‌లోని కొంత బిట్ 0 నుండి 1కి టోగుల్ చేయబడిందని అనుకుందాం.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "దీని అర్థం ఏమిటంటే, ఆ బిట్ యొక్క స్థానం ఇప్పుడు మొత్తం XORలో చేర్చబడుతుంది, ఇది మొత్తాన్ని 0 నుండి బదులుగా ఈ కొత్తగా చేర్చబడిన విలువ, లోపం యొక్క స్థానంగా మారుస్తుంది.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "మేము డేటా బ్లాక్‌ను అనుకరించడానికి 16 1సె మరియు 0 సె యాదృచ్ఛిక శ్రేణిని సృష్టించడం ద్వారా ప్రారంభిస్తాము మరియు నేను దానికి బిట్‌లను ఇస్తాను, అయితే ఆచరణలో ఇది మనం పంపినవారి నుండి స్వీకరించేదే అవుతుంది మరియు బదులుగా యాదృచ్ఛికంగా ఇది 5 పారిటీ బిట్‌లతో కలిపి 11 డేటా బిట్‌లను కలిగి ఉంటుంది.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "కాబట్టి మనం ఈ అన్ని జతలపై లూప్ చేసే జాబితాను సృష్టించినట్లయితే, i లాగా కనిపించే జంటలు, ఆపై మేము కేవలం i విలువను, కేవలం సూచికను తీసివేస్తే, అది అంత ఉత్తేజకరమైనది కాదు, మేము ఆ సూచికలను 0 నుండి 15 వరకు తిరిగి పొందుతాము.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "కానీ మనం దీన్ని బిట్ అయితే మాత్రమే చేయాలనే షరతును జోడిస్తే, అంటే ఆ బిట్ 1 మరియు 0 కాకపోతే, అది సంబంధిత బిట్ ఆన్ చేయబడిన స్థానాలను మాత్రమే బయటకు తీస్తుంది.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "మేము దీన్ని ఇక్కడ చేయము, కానీ పంపినవారు నాలుగు పారిటీ బిట్‌లను అవసరమైన విధంగా సెట్ చేయడానికి బైనరీ ప్రాతినిధ్యాన్ని ఉపయోగించే ఒక ఫంక్షన్‌ను మీరు వ్రాయవచ్చు, చివరికి ఈ బ్లాక్‌ని బిట్‌ల పూర్తి జాబితాలో ఈ లైన్ కోడ్‌ని అమలు చేసే స్థితికి చేరుకుంటుంది. ఒక 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "మంచి విషయం ఏమిటంటే, శబ్దం నుండి యాదృచ్ఛిక లోపాన్ని అనుకరిస్తూ, ఈ జాబితాలోని ఏదైనా బిట్‌లను మనం టోగుల్ చేస్తే, మీరు ఇదే లైన్ కోడ్‌ను అమలు చేస్తే, అది ఆ లోపాన్ని ముద్రిస్తుంది.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "మీరు ఈ బ్లాక్‌ను నీలిరంగు నుండి పొందవచ్చు, దానిపై ఈ సింగిల్ లైన్‌ను అమలు చేయవచ్చు మరియు అది స్వయంచాలకంగా లోపం యొక్క స్థానం లేదా ఏదైనా లేకుంటే 0ని ఉమ్మివేస్తుంది.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "ఇప్పుడు, బైనరీ మరియు XORలు మరియు సాధారణంగా సాఫ్ట్‌వేర్‌తో మీ సౌకర్యాన్ని బట్టి, మీరు ఈ దృక్పథాన్ని కొంచెం గందరగోళంగా లేదా చాలా సొగసైన మరియు సరళంగా కనుగొనవచ్చు, మేము దీన్ని ఎందుకు ప్రారంభించలేదని మీరు ఆశ్చర్యపోతున్నారు. -వెళ్ళండి.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "వదులుగా చెప్పాలంటే, హార్డ్‌వేర్‌లో హామింగ్ కోడ్‌లను నేరుగా అమలు చేసేటప్పుడు బహుళ పారిటీ తనిఖీ దృక్పథం గురించి ఆలోచించడం సులభం, మరియు XOR దృక్పథాన్ని సాఫ్ట్‌వేర్‌లో చేసేటప్పుడు, ఉన్నత స్థాయి నుండి ఆలోచించడం చాలా సులభం.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "ఇక్కడ సంబంధిత వాస్తవం ఏమిటంటే, ఆ సమాచారం మనకు ఎంత రిడెండెన్సీ అవసరమో దానికి నేరుగా అనుగుణంగా ఉంటుంది.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "ఆపై, మార్గం ద్వారా, మీరు కొన్నిసార్లు హామింగ్ కోడ్‌లను ప్రదర్శించే ఈ మొత్తం ఇతర మార్గం ఉంది, ఇక్కడ మీరు సందేశాన్ని ఒక పెద్ద మ్యాట్రిక్స్ ద్వారా గుణిస్తారు.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "మరియు స్కేలింగ్ గురించి చెప్పాలంటే, మేము బ్లాక్ పరిమాణాన్ని పెంచుతున్నప్పుడు మాత్రమే ఈ పథకం యొక్క సామర్థ్యం మెరుగుపడుతుందని మీరు గమనించవచ్చు.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "ఉదాహరణకు, 256 బిట్‌లతో, మీరు రిడెండెన్సీ కోసం ఆ స్థలంలో 3% మాత్రమే ఉపయోగిస్తున్నారని మేము చూశాము మరియు అది అక్కడ నుండి మెరుగుపడుతోంది.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "పారిటీ బిట్‌ల సంఖ్య ఒక్కొక్కటిగా పెరుగుతున్న కొద్దీ, బ్లాక్ పరిమాణం రెట్టింపు అవుతూ ఉంటుంది.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "మరియు మీరు దానిని విపరీతంగా తీసుకుంటే, మీరు మిలియన్ బిట్‌లతో బ్లాక్‌ను కలిగి ఉండవచ్చు, ఇక్కడ మీరు మీ పారిటీ తనిఖీలతో అక్షరాలా 20 ప్రశ్నలను ప్లే చేస్తారు మరియు ఇది 21 పారిటీ బిట్‌లను మాత్రమే ఉపయోగిస్తుంది.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "సమస్య ఏమిటంటే, పెద్ద బ్లాక్‌తో, ఒకటి లేదా రెండు కంటే ఎక్కువ బిట్ ఎర్రర్‌లను చూసే సంభావ్యత పెరుగుతుంది మరియు హామింగ్ కోడ్‌లు అంతకు మించి దేనినీ నిర్వహించవు.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "కానీ అది మరొక సారి చర్చనీయాంశం.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "అతని పుస్తకం ది ఆర్ట్ ఆఫ్ డూయింగ్ సైన్స్ అండ్ ఇంజినీరింగ్‌లో, హామింగ్ ఈ కోడ్‌ని తన కనిపెట్టడం ఎంత మెలికలు తిరిగిపోయిందో అద్భుతంగా చెప్పాడు.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "అతను లూయిస్ పాశ్చర్ కోట్‌ను ప్రస్తావించిన అరడజను సార్లు ఈ పుస్తకంలో ఉన్నాయి, అదృష్టం సిద్ధమైన మనస్సుకు అనుకూలంగా ఉంటుంది.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "అయితే అవి స్పష్టంగా కనిపిస్తున్నాయని భావించి మిమ్మల్ని మీరు మోసం చేసుకోకూడదు, ఎందుకంటే అవి ఖచ్చితంగా కావు.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "బిట్ ఫ్లిప్‌ల సంభావ్యత ఎంత ఎక్కువగా ఉన్నా, కనీసం థియరీలో అయినా సమర్థవంతమైన లోపాన్ని సరిదిద్దడం ఎల్లప్పుడూ సాధ్యమేనని ఒక నిర్దిష్ట కోణంలో చూపించిన అదే పునాది పేపర్.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "కొన్ని దశాబ్దాలుగా ఫాస్ట్ ఫార్వార్డ్, మరియు ఈ రోజుల్లో, మనలో చాలా మంది బిట్స్ మరియు సమాచారం గురించి ఆలోచించడంలో మునిగిపోయారు, ఈ ఆలోచనా విధానం ఎంత విభిన్నంగా ఉందో పట్టించుకోవడం సులభం.",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/thai/sentence_translations.json b/2020/hamming-codes-2/thai/sentence_translations.json
index 9f666cba2..2559b7d2c 100644
--- a/2020/hamming-codes-2/thai/sentence_translations.json
+++ b/2020/hamming-codes-2/thai/sentence_translations.json
@@ -1,6 +1,6 @@
 [
  {
-  "input": "I'm assuming that everybody here is coming from part 1. ",
+  "input": "I'm assuming that everybody here is coming from part 1.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it. ",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error. ",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -24,7 +24,7 @@
   "end": 27.16
  },
  {
-  "input": "In that video the goal was to make Hamming codes feel as hands-on and rediscoverable as possible. ",
+  "input": "In that video the goal was to make Hamming codes feel as hands-on and rediscoverable as possible.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -32,7 +32,7 @@
   "end": 34.6
  },
  {
-  "input": "hat there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error. In that video, the goal was to make Hamming codes feel as hands-on and rediscoverable as possible. But as ",
+  "input": "But as you start to think about actually implementing this, either in software or hardware, that framing may actually undersell how elegant these codes really are.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -40,7 +40,7 @@
   "end": 43.46
  },
  {
-  "input": "You might think that you need to write an algorithm that keeps track of all the possible error locations and cuts that group in half with each check, but it's actually way, way simpler than that. ",
+  "input": "You might think that you need to write an algorithm that keeps track of all the possible error locations and cuts that group in half with each check, but it's actually way, way simpler than that.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -48,7 +48,7 @@
   "end": 53.48
  },
  {
-  "input": "If you read out the answers to the four parity checks we did in the last video, all as 1s and 0s instead of yeses and nos, it literally spells out the position of the error in binary. ",
+  "input": "If you read out the answers to the four parity checks we did in the last video, all as 1s and 0s instead of yeses and nos, it literally spells out the position of the error in binary.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "you read out the answers to the four parity checks we did in the last video, all as ones and zeros instead of yeses and nos, it literally spells out ",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last. ",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day. The goal here is to give you a very thorough understanding of one of the earlie ",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -80,7 +80,7 @@
   "end": 87.54
  },
  {
-  "input": "st examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity groups, and the second, and the third, but not the last. So reading the results of those four checks ",
+  "input": "There's nothing special about the example 7, this works in general, and this makes the logic for implementing the whole scheme in hardware shockingly simple.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -88,7 +88,7 @@
   "end": 95.82
  },
  {
-  "input": "Now if you want to see why this magic happens, take these 16 index labels for our positions, but instead of writing them in base 10, let's write them all in binary, running from 0000 up to 1111. ",
+  "input": "Now if you want to see why this magic happens, take these 16 index labels for our positions, but instead of writing them in base 10, let's write them all in binary, running from 0000 up to 1111.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent. ",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from. ",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary. ",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -120,7 +120,7 @@
   "end": 132.36
  },
  {
-  "input": "0, let's write them all in binary, running from 0000 up to 1111. ask feels at the star ",
+  "input": "It's worth it, though.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -128,7 +128,7 @@
   "end": 134.12
  },
  {
-  "input": "Focus your attention just on that last bit of all of these labels, and then highlight the positions where that final bit is a 1. ",
+  "input": "Focus your attention just on that last bit of all of these labels, and then highlight the positions where that final bit is a 1.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1? ",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -144,7 +144,7 @@
   "end": 155.74
  },
  {
-  "input": "Similarly, if you focus on the second to last bit, and highlight all the positions where that's a 1, you get the second parity group from our scheme. ",
+  "input": "Similarly, if you focus on the second to last bit, and highlight all the positions where that's a 1, you get the second parity group from our scheme.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -152,7 +152,7 @@
   "end": 166.16
  },
  {
-  "input": "ly spelled words. Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. ",
+  "input": "In other words, that second check is asking, hey, me again, if there's an error, is the second to last bit of that position a 1?",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "And so on. ",
+  "input": "And so on.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -168,7 +168,7 @@
   "end": 176.9
  },
  {
-  "input": "The third parity check covers every position whose third to last bit is turned on, and the last one covers the last eight positions, those ones whose highest order bit is a 1. ",
+  "input": "The third parity check covers every position whose third to last bit is turned on, and the last one covers the last eight positions, those ones whose highest order bit is a 1.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -176,7 +176,7 @@
   "end": 188.74
  },
  {
-  "input": "everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary. ",
+  "input": "Everything we did earlier is the same as answering these four questions, which in turn is the same as spelling out a position in binary.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -184,7 +184,7 @@
   "end": 197.74
  },
  {
-  "input": "It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where tha ",
+  "input": "I hope this makes two things clearer.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "t final bit is a 1. What we get is the first of our four parity groups, which means that you can interpret that first check as asking, hey, if there's an err ",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "ฉันเดาว่าทุกคนที่นี่มาจากภาค 1 เรากำลังพูดถึงโค้ด Hamming ซึ่งเป็นวิธีในการสร้างบล็อกข้อมูลที่บิตส่วนใหญ่มีข้อความที่มีความหมาย ในขณะที่บิตอื่นๆ บางส่วนทำหน้าที่เป็นการซ้ำซ้อน ในลักษณะที่ว่าหากบิตใด ๆ พลิกกลับ ข้อความก็อาจเป็นข้อความหนึ่งก็ได้ บิตหรือบิตสำรอง อะไรก็ตามในบล็อกนี้ ผู้รับจะสามารถระบุได้ว่ามีข้อผิดพลาด และวิธีการแก้ไข แนวคิดพื้นฐานที่นำเสนอคือวิธีใช้การตรวจสอบพาริตีหลายรายการเพื่อค้นหาแบบไบนารี่ไปจนถึงข้อผิดพลาด  ในวิดีโอนั้นเป้าหมายคือการทำให้โค้ด Hamming รู้สึกเหมือนได้ลงมือปฏิบัติจริงและสามารถค้นพบใหม่ได้มากที่สุดเท่าที่จะเป็นไปได้ แต่เมื่อคุณเริ่มคิดถึงการนำสิ่งนี้ไปใช้จริง ทั้งในซอฟต์แวร์หรือฮาร์ดแวร์ เฟรมนั้นอาจตอกย้ำว่าโค้ดเหล่านี้สวยงามเพียงใด คุณอาจคิดว่าคุณจำเป็นต้องเขียนอัลกอริทึมที่ติดตามตำแหน่งข้อผิดพลาดที่เป็นไปได้ทั้งหมด และลดกลุ่มนั้นลงครึ่งหนึ่งในการตรวจสอบแต่ละครั้ง แต่จริงๆ แล้วเป็นวิธีที่ง่ายกว่านั้นมาก หากคุณอ่านคำตอบของการตรวจสอบความเท่าเทียมกันทั้งสี่ครั้งที่เราทำในวิดีโอที่แล้ว ทั้งหมดเป็น 1 และ 0 แทนที่จะเป็นใช่และไม่ใช่ มันจะสะกดตำแหน่งของข้อผิดพลาดในรูปแบบไบนารี่ ตัวอย่างเช่น เลข 7 ในไบนารี่ดูเหมือน 0111 โดยพื้นฐานแล้วบอกว่ามันคือ 4 บวก 2 บวก 1 และสังเกตว่าตำแหน่งที่ 7 อยู่ที่ใด มันจะส่งผลต่อกลุ่มพาริตีกลุ่มแรกของเรา และกลุ่มที่สองและกลุ่มที่สาม แต่ไม่ใช่กลุ่มสุดท้าย ดังนั้นการอ่านผลการตรวจสอบทั้งสี่ครั้งจากล่างขึ้นบนจะช่วยระบุตำแหน่งของข้อผิดพลาดได้อย่างแน่นอน  ไม่มีอะไรพิเศษเกี่ยวกับตัวอย่างที่ 7 ซึ่งใช้งานได้โดยทั่วไป และทำให้ตรรกะในการใช้โครงร่างทั้งหมดในฮาร์ดแวร์เป็นเรื่องง่ายอย่างน่าตกใจ ตอนนี้ หากคุณต้องการดูว่าเหตุใดเหตุการณ์มหัศจรรย์นี้จึงเกิดขึ้น ให้นำป้ายกำกับดัชนีทั้ง 16 รายการสำหรับตำแหน่งของเรา แต่แทนที่จะเขียนเป็นฐาน 10 ให้เขียนทั้งหมดในรูปแบบไบนารี่ โดยเริ่มจาก 0000 ถึง 1111 ขณะที่เราใส่ป้ายกำกับไบนารี่เหล่านี้กลับเข้าไปในกล่อง ฉันขอย้ำว่าป้ายเหล่านี้แตกต่างจากข้อมูลที่ถูกส่งจริง สิ่งเหล่านี้เป็นเพียงป้ายกำกับแนวคิดที่จะช่วยให้คุณและฉันเข้าใจว่ากลุ่มความเท่าเทียมกันทั้งสี่มาจากไหน  ความสง่างามของการมีทุกสิ่งที่เรากำลังดูถูกอธิบายในรูปแบบไบนารี่อาจถูกลดทอนลงด้วยความสับสนของการมีทุกสิ่งที่เรากำลังดูถูกอธิบายในรูปแบบไบนารี  มันก็คุ้มค่านะ มุ่งความสนใจของคุณไปที่ส่วนสุดท้ายของป้ายกำกับเหล่านี้ทั้งหมด จากนั้นไฮไลต์ตำแหน่งที่บิตสุดท้ายคือ 1 สิ่งที่เราได้รับคือกลุ่มพาริตีกลุ่มแรกจากสี่กลุ่ม ซึ่งหมายความว่าคุณสามารถตีความการตรวจสอบครั้งแรกเป็นการถามว่า เฮ้ หากมีข้อผิดพลาด บิตสุดท้ายในตำแหน่งของข้อผิดพลาดนั้นเป็น 1 หรือไม่ ในทำนองเดียวกัน หากคุณเน้นที่บิตที่สองถึงบิตสุดท้าย และเน้นตำแหน่งทั้งหมดที่เป็น 1 คุณจะได้กลุ่มแพริตีที่สองจากแผนของเรา กล่าวอีกนัยหนึ่ง การตรวจสอบครั้งที่สองจะถามว่า เฮ้ ฉันอีกครั้ง หากมีข้อผิดพลาด บิตที่สองจากบิตสุดท้ายของตำแหน่งนั้นเป็น 1 หรือไม่ และอื่นๆ การตรวจสอบพาริตี้ครั้งที่สามครอบคลุมทุกตำแหน่งที่เปิดบิตที่สามถึงสุดท้าย และการตรวจสอบสุดท้ายครอบคลุมแปดตำแหน่งสุดท้าย ซึ่งบิตลำดับสูงสุดคือ 1 ทุกสิ่งที่เราทำก่อนหน้านี้เหมือนกับการตอบคำถามสี่ข้อนี้ ซึ่งในทางกลับกันก็เหมือนกับการสะกดตำแหน่งในรูปแบบไบนารี่ ฉันหวังว่านี่จะทำให้สองสิ่งชัดเจนขึ้น ประการแรกคือวิธีการสรุปอย่างเป็นระบบเกี่ยวกับขนาดบล็อกที่มีพลังมากกว่าสอง หากต้องใช้บิตมากกว่าในการอธิบายแต่ละตำแหน่ง เช่น หกบิตเพื่ออธิบาย 64 จุด แต่ละบิตเหล่านั้นจะให้หนึ่งในกลุ่มพาริตีที่เราต้องตรวจสอบ บรรดาผู้ที่ดูปริศนากระดานหมากรุกที่ฉันทำกับแมตต์ ปาร์กเกอร์อาจพบว่าทั้งหมดนี้คุ้นเคยอย่างยิ่ง มันเป็นตรรกะหลักเดียวกัน แต่แก้ปัญหาที่แตกต่าง และนำไปใช้กับกระดานหมากรุกขนาด 64 สี่เหลี่ยม สิ่งที่สองที่ฉันหวังว่าสิ่งนี้จะทำให้ชัดเจนคือเหตุใดแพริตีบิตของเราจึงนั่งอยู่ในตำแหน่งที่เป็นกำลังของสอง เช่น 1, 2, 4 และ 8 ตำแหน่งเหล่านี้คือตำแหน่งที่การแสดงไบนารี่เปิดขึ้นเพียงเล็กน้อย นั่นหมายความว่าแต่ละแพริตีบิตเหล่านั้นอยู่ภายในกลุ่มพาริตีเพียงกลุ่มเดียวจากสี่กลุ่มเท่านั้น  คุณยังสามารถดูสิ่งนี้ได้ในตัวอย่างที่ใหญ่กว่า โดยไม่ว่าคุณจะได้ขนาดใหญ่แค่ไหน แต่ละบิตของพาริตีจะแตะเพียงกลุ่มใดกลุ่มหนึ่งได้อย่างสะดวก เมื่อคุณเข้าใจว่าการตรวจสอบความเท่าเทียมกันเหล่านี้ที่เราทุ่มเทเวลาส่วนใหญ่นั้นไม่มีอะไรมากไปกว่าวิธีที่ชาญฉลาดในการระบุตำแหน่งของข้อผิดพลาดในรูปแบบไบนารี่ จากนั้นเราก็สามารถเชื่อมโยงด้วยวิธีคิดที่แตกต่างออกไปเกี่ยวกับการแฮมมิง รหัส ซึ่งอาจจะเรียบง่ายกว่าและสวยงามกว่ามาก และโดยทั่วไปแล้วสามารถเขียนลงไปได้ด้วยโค้ดเพียงบรรทัดเดียว มันขึ้นอยู่กับฟังก์ชัน XOR XOR สำหรับคนที่ไม่รู้จัก ย่อมาจาก Exclusive or เมื่อคุณรับ XOR ของสองบิต มันจะคืนค่า 1 หากบิตใดบิตหนึ่งนั้นเปิดอยู่ แต่จะไม่ได้ถ้าทั้งสองเปิดหรือปิด หากใช้ถ้อยคำต่างกัน มันคือความเท่าเทียมกันของสองบิตนี้ ในฐานะคนคณิต ฉันชอบคิดว่ามันเป็นการบวก mod 2 โดยทั่วไปเรายังพูดถึง XOR ของสตริงบิตที่แตกต่างกันสองตัว ซึ่งโดยพื้นฐานแล้วจะทำส่วนประกอบนี้ทีละส่วนประกอบ มันเหมือนกับการเติม แต่ที่คุณไม่เคยพกติดตัว ขอย้ำอีกครั้งว่ายิ่งมีความโน้มเอียงทางคณิตศาสตร์มากขึ้นอาจชอบคิดว่านี่เป็นการเพิ่มเวกเตอร์สองตัวและลด mod 2 หากคุณเปิด Python ขึ้นมาตอนนี้และใช้การดำเนินการเครื่องหมายรูปหมวกระหว่างจำนวนเต็มสองตัว นี่คือสิ่งที่มันกำลังทำอยู่ ยกเว้นการแสดงบิตของตัวเลขเหล่านั้นภายใต้ประทุน ประเด็นสำคัญสำหรับคุณและฉันคือการรับ XOR ของสตริงบิตต่างๆ มากมายเป็นวิธีที่มีประสิทธิภาพในการคำนวณการล้อเลียนกลุ่มกลุ่มที่แยกจากกัน เช่นเดียวกับคอลัมน์ ทั้งหมดในคราวเดียว สิ่งนี้ทำให้เรามีวิธีที่ค่อนข้างเก๋ในการคิดเกี่ยวกับการตรวจสอบพาริตีหลายรายการจากอัลกอริธึมโค้ด Hamming ของเรา โดยที่ทั้งหมดนี้ถูกรวมเข้าด้วยกันเป็นการดำเนินการเดียว แม้ว่ามองแวบแรกจะดูแตกต่างออกไปมากก็ตาม เขียนตำแหน่งทั้ง 16 ตำแหน่งในรูปแบบไบนารี่อย่างที่เราเคยมีมาก่อน และตอนนี้เน้นตำแหน่งที่บิตข้อความเปิดเป็น 1 จากนั้นรวบรวมตำแหน่งเหล่านี้เป็นคอลัมน์ขนาดใหญ่คอลัมน์เดียวแล้วรับ XOR คุณอาจเดาได้ว่าผลลัพธ์ 4 บิตที่อยู่ด้านล่างนั้นเหมือนกับการตรวจสอบความเท่าเทียมกัน 4 รายการที่เรารู้จักและชื่นชอบ แต่ใช้เวลาสักครู่เพื่อคิดจริงๆ ว่าเหตุใดจึงเป็นเช่นนั้น ตัวอย่างเช่น คอลัมน์สุดท้ายนี้ กำลังนับตำแหน่งทั้งหมดที่มีบิตสุดท้ายเป็น 1 แต่เราจำกัดไว้เฉพาะตำแหน่งที่ไฮไลต์อยู่แล้ว ดังนั้นจึงเป็นการนับอย่างมีประสิทธิภาพว่าตำแหน่งที่ไฮไลต์กี่ตำแหน่งมาจากกลุ่มแพริตีกลุ่มแรก นั่นสมเหตุสมผลไหม? ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -200,7 +200,7 @@
   "end": 206.46
  },
  {
-  "input": "If it takes more bits to describe each position, like six bits to describe 64 spots, then each of those bits gives you one of the parity groups that we need to check. ",
+  "input": "If it takes more bits to describe each position, like six bits to describe 64 spots, then each of those bits gives you one of the parity groups that we need to check.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -208,7 +208,7 @@
   "end": 216.68
  },
  {
-  "input": "maybe at the end or something like that, but as you'll see, having them sit in positions which are powers of 2 allows for something that's really elegant by the end. ",
+  "input": "Those of you who watched the chessboard puzzle I did with Matt Parker might find all this exceedingly familiar.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -216,7 +216,7 @@
   "end": 223.18
  },
  {
-  "input": "It's the same core logic, but solving a different problem, and applied to a 64-squared chessboard. ",
+  "input": "It's the same core logic, but solving a different problem, and applied to a 64-squared chessboard.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -224,7 +224,7 @@
   "end": 228.78
  },
  {
-  "input": "The second thing I hope this makes clear is why our parity bits are sitting in the positions that are powers of two, for example 1, 2, 4, and 8. ",
+  "input": "The second thing I hope this makes clear is why our parity bits are sitting in the positions that are powers of two, for example 1, 2, 4, and 8.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -232,7 +232,7 @@
   "end": 237.32
  },
  {
-  "input": "at goes on at position 0, but don't worry about that for now. The third parity check covers every position whose third to last bit is turned ",
+  "input": "These are the positions whose binary representation has just a single bit turned on.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups. ",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -248,7 +248,7 @@
   "end": 249.46
  },
  {
-  "input": "You can also see this in larger examples, where no matter how big you get, each parity bit conveniently touches only one of the groups. ",
+  "input": "You can also see this in larger examples, where no matter how big you get, each parity bit conveniently touches only one of the groups.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -256,7 +256,7 @@
   "end": 259.34
  },
  {
-  "input": "Once you understand that these parity checks that we've focused so much of our time on are nothing more than a clever way to spell out the position of an error in binary, then we can draw a connection with a different way to think about hamming codes, one that is arguably a lot simpler and more elegant, and which can basically be written down with a single line of code. ",
+  "input": "Once you understand that these parity checks that we've focused so much of our time on are nothing more than a clever way to spell out the position of an error in binary, then we can draw a connection with a different way to think about hamming codes, one that is arguably a lot simpler and more elegant, and which can basically be written down with a single line of code.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -264,7 +264,7 @@
   "end": 283.24
  },
  {
-  "input": "It's based on the XOR function. ",
+  "input": "It's based on the XOR function.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -272,7 +272,7 @@
   "end": 285.5
  },
  {
-  "input": "f 1s in the message is an even number. So for example right now, that total number of 1s is If it takes more bits to describe each p ",
+  "input": "XOR, for those of you who don't know, stands for exclusive or.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "osition, like six bits to describe 64 spots, then each of those bits gives you one of the parity groups that we need to check. that special bit to be a 1, making the count even. But if the block had already started off with a ",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "Phrased differently, it's the parity of these two bits. ",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -296,7 +296,7 @@
   "end": 302.98
  },
  {
-  "input": "it would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core ",
+  "input": "As a math person, I prefer to think about it as addition mod 2.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -304,7 +304,7 @@
   "end": 306.76
  },
  {
-  "input": "logic, but solving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity bits are sitti ",
+  "input": "We also commonly talk about the XOR of two different bit strings, which basically does this component by component.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "It's like addition, but where you never carry. ",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -320,7 +320,7 @@
   "end": 315.72
  },
  {
-  "input": "Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. ",
+  "input": "Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -328,7 +328,7 @@
   "end": 322.48
  },
  {
-  "input": "of two, for example 1, 2, 4, and 8. These are the positions whose binary representation has just a single bit turned on. d say the parity is 0 or 1, which is typically more helpful once you start doing math with the idea. And this special bit that the sender uses to con ",
+  "input": "If you open up some Python right now and apply the caret operation between two integers, this is what it's doing but to the bit representations of those numbers under the hood.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "trol the parity is called the parity bit. And actually, we should be clear, if the receiver sees an odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure tha ",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation. ",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -352,7 +352,7 @@
   "end": 358.78
  },
  {
-  "input": "Though at first glance it does look very different. ",
+  "input": "Though at first glance it does look very different.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -360,7 +360,7 @@
   "end": 362.18
  },
  {
-  "input": "Specifically write down the 16 positions in binary, like we had before, and now highlight the positions where the message bit is turned on to a 1, and then collect these positions into one big column and take the XOR. ",
+  "input": "Specifically write down the 16 positions in binary, like we had before, and now highlight the positions where the message bit is turned on to a 1, and then collect these positions into one big column and take the XOR.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -368,7 +368,7 @@
   "end": 377.1
  },
  {
-  "input": "You can probably guess that the 4 bits sitting at the bottom as a result are the same as the 4 parity checks we've come to know and love, but take a moment to actually think about why exactly. ",
+  "input": "You can probably guess that the 4 bits sitting at the bottom as a result are the same as the 4 parity checks we've come to know and love, but take a moment to actually think about why exactly.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -376,7 +376,7 @@
   "end": 389.2
  },
  {
-  "input": "This last column, for example, is counting all of the positions whose last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. ",
+  "input": "This last column, for example, is counting all of the positions whose last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is ",
+  "input": "Does that make sense?",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "turned on, but not if both are turned on or if both are turned off. Phrased differently, it's the parity of these two bits. full message down to a single bit, what they give us is a powerful building block for more sophisticated schemes. ",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -400,7 +400,7 @@
   "end": 420.0
  },
  {
-  "input": "It's really just a small shift in perspective on the same thing we've been doing. ",
+  "input": "It's really just a small shift in perspective on the same thing we've been doing.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -408,7 +408,7 @@
   "end": 423.96
  },
  {
-  "input": "e also commonly talk about the XOR of two different bit s ",
+  "input": "And so you know where it goes from here.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -416,7 +416,7 @@
   "end": 429.6
  },
  {
-  "input": "The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000. ",
+  "input": "The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error. ",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "Let's say some bit in this block gets toggled from a 0 to a 1. ",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. ",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -448,7 +448,7 @@
   "end": 463.82
  },
  {
-  "input": "Slightly less obviously, the same is true if there's an error that changes a 1 to a 0. ",
+  "input": "Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -456,7 +456,7 @@
   "end": 469.36
  },
  {
-  "input": "ey point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop. This gives us a rather snazzy way ",
+  "input": "You see, if you add a bit string together twice, it's the same as not having it there at all, basically because in this world 1 plus 1 equals 0.",
   "translatedText": "ในทำนองเดียวกัน คอลัมน์ถัดไปจะนับจำนวนตำแหน่งที่อยู่ในกลุ่มพาริตีที่สอง ตำแหน่งที่บิตที่สองถึงสุดท้ายคือ 1 และตำแหน่งที่ถูกไฮไลต์ด้วย และอื่นๆ มันเป็นเพียงการเปลี่ยนแปลงเล็กๆ น้อยๆ ในมุมมองต่อสิ่งเดียวกันที่เราทำอยู่ แล้วคุณจะรู้ว่ามันไปจากที่นี่ที่ไหน ผู้ส่งมีหน้าที่รับผิดชอบในการสลับบิตพาริตีพิเศษบางส่วนเพื่อให้แน่ใจว่าผลรวมจะเป็น 0000 ตอนนี้เมื่อเรามีแบบนี้แล้ว นี่ทำให้เรามีวิธีที่ดีที่จะคิดว่าเหตุใดผลลัพธ์สี่บิตที่อยู่ด้านล่างจึงสะกดตำแหน่งของข้อผิดพลาดได้โดยตรง สมมติว่าบางส่วนในบล็อกนี้มีการสลับจาก 0 เป็น 1 ความหมายก็คือตอนนี้ตำแหน่งของบิตนั้นจะถูกรวมไว้ใน XOR ทั้งหมด ซึ่งเปลี่ยนผลรวมจาก 0 เป็นค่าที่รวมใหม่แทน ซึ่งเป็นตำแหน่งของข้อผิดพลาด เห็นได้ชัดว่าน้อยกว่าเล็กน้อย กรณีเดียวกันนี้จะเกิดขึ้นหากมีข้อผิดพลาดที่เปลี่ยน 1 เป็น 0 คุณจะเห็นว่า ถ้าคุณบวกสตริงบิตเข้าด้วยกันสองครั้ง มันก็เหมือนกับการไม่มีมันเลย โดยพื้นฐานแล้ว เพราะในโลกนี้ 1 บวก 1 เท่ากับ 0 ดังนั้นการเพิ่มสำเนาของตำแหน่งนี้เข้ากับผลรวมทั้งหมดจะมีผลเช่นเดียวกับที่เรากำลังย้ายตำแหน่ง  และผลกระทบนั้นอีกครั้ง ก็คือผลลัพธ์รวมที่อยู่ด้านล่างสุดนี้ ระบุตำแหน่งของข้อผิดพลาด เพื่อแสดงให้เห็นว่าสิ่งนี้สวยงามเพียงใด ฉันขอแสดงโค้ด Python หนึ่งบรรทัดที่ฉันอ้างถึงก่อนหน้านี้ ซึ่งจะรวบรวมตรรกะเกือบทั้งหมดในส่วนท้ายของผู้รับ เราจะเริ่มต้นด้วยการสร้างอาร์เรย์สุ่ม 16 1 วินาทีและ 0 เพื่อจำลองบล็อกข้อมูล และฉันจะตั้งชื่อบิตให้กับมัน แต่แน่นอนว่าในทางปฏิบัติ นี่จะเป็นสิ่งที่เราได้รับจากผู้ส่ง และแทนที่จะเป็น ถ้าสุ่มก็จะบรรทุกข้อมูล 11 บิตพร้อมกับพาริตีบิต 5 บิต ถ้าฉันเรียกใช้ฟังก์ชัน enumerateBits สิ่งที่มันทำคือจับคู่แต่ละบิตเหล่านั้นกับดัชนีที่สอดคล้องกัน ในกรณีนี้คือทำงานตั้งแต่ 0 ถึง 15 ดังนั้นหากเราสร้างรายการที่วนซ้ำคู่เหล่านี้ทั้งหมด คู่ที่ดูเหมือน i แล้วเราดึงเฉพาะค่า i ออกมา แค่ดัชนี มันไม่น่าตื่นเต้นขนาดนั้น เราแค่นำดัชนีเหล่านั้นกลับมา 0 ถึง 15 . ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -464,7 +464,7 @@
   "end": 477.94
  },
  {
-  "input": "to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation. ",
+  "input": "So adding a copy of this position to the total sum has the same effect as we're moving it.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -472,7 +472,7 @@
   "end": 484.3
  },
  {
-  "input": "Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the mes ",
+  "input": "And that effect, again, is that the total result at the bottom here spells out the position of the error.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -480,7 +480,7 @@
   "end": 490.7
  },
  {
-  "input": "sage bit is turned on to a 1, and then collect these positions into one big column and take the XOR. You can probably guess that the four bits sitting at the bottom as a resu ",
+  "input": "To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all of the logic on the receiver's end.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "lt are the same as the four parity checks we've come to know and love, but take a moment to actually think about why exactly. This last column, for example, is counting all of the positions whose last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. ",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -496,7 +496,7 @@
   "end": 517.4
  },
  {
-  "input": "If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15. ",
+  "input": "If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ht half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit, so these 8 bits already have an even pari Likewise, the next column counts how many positions are in the second parity group, the positions whose second to las ",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on. ",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -520,7 +520,7 @@
   "end": 552.66
  },
  {
-  "input": "ve on the same thing we've been doing. but for right now we're going to assume ",
+  "input": "In this case it looks like those positions are 0, 4, 6, 9, etc.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -528,7 +528,7 @@
   "end": 557.96
  },
  {
-  "input": "What we want is to collect together all of those positions, the positions of the bits that are turned on, and then XOR them together. ",
+  "input": "What we want is to collect together all of those positions, the positions of the bits that are turned on, and then XOR them together.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -536,7 +536,7 @@
   "end": 567.24
  },
  {
-  "input": "The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 000 ",
+  "input": "To do this in Python, let me first import a couple helpful functions.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -544,7 +544,7 @@
   "end": 573.22
  },
  {
-  "input": "That way we can call reduce() on this list, and use the XOR function to reduce it. ",
+  "input": "That way we can call reduce() on this list, and use the XOR function to reduce it.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -552,7 +552,7 @@
   "end": 578.7
  },
  {
-  "input": "es us a really nice way to think about why these four resulting bits at the bottom directly spell out the pos ",
+  "input": "This basically eats its way through the list, taking XORs along the way.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -560,7 +560,7 @@
   "end": 582.68
  },
  {
-  "input": "ition of an error. Let's say you detect an error among the odd columns, and among the right half. It necessarily means the error is somewhere in th ",
+  "input": "If you prefer, you can explicitly write out that XOR function without having to import it from anywhere.",
   "translatedText": "แต่ถ้าเราเพิ่มเงื่อนไขให้ทำสิ่งนี้เฉพาะ if bit ซึ่งหมายความว่าถ้าบิตนั้นเป็น 1 ไม่ใช่ 0 มันก็จะดึงเฉพาะตำแหน่งที่เปิดบิตที่เกี่ยวข้องออกมาเท่านั้น ในกรณีนี้ ดูเหมือนว่าตำแหน่งเหล่านั้นคือ 0, 4, 6, 9 เป็นต้น สิ่งที่เราต้องการคือการรวบรวมตำแหน่งทั้งหมดเหล่านั้น ตำแหน่งของบิตที่เปิดอยู่ จากนั้น XOR เข้าด้วยกัน หากต้องการทำสิ่งนี้ใน Python ก่อนอื่นให้ฉันนำเข้าฟังก์ชันที่เป็นประโยชน์สองสามรายการก่อน ด้วยวิธีนี้เราสามารถเรียกย่อ () ในรายการนี้ และใช้ฟังก์ชัน XOR เพื่อลดค่านั้น โดยพื้นฐานแล้วสิ่งนี้จะกินทางผ่านรายการโดยนำ XOR ไปพร้อมกัน หากต้องการ คุณสามารถเขียนฟังก์ชัน XOR นั้นอย่างชัดเจนโดยไม่ต้องนำเข้าจากที่ใดก็ได้ ดังนั้นในขณะนี้ ดูเหมือนว่าถ้าเราทำเช่นนี้กับบล็อกสุ่มของเราที่มีขนาด 16 บิต มันจะคืนค่า 9 ซึ่งมีเลขฐานสองแทน 1001 เราจะไม่ทำที่นี่ แต่คุณสามารถเขียนฟังก์ชันที่ผู้ส่งใช้การแทนค่าไบนารีนั้นเพื่อตั้งค่าบิตพาริตีทั้งสี่ตามต้องการ ในท้ายที่สุดทำให้บล็อกนี้อยู่ในสถานะที่รันโค้ดบรรทัดนี้ในรายการบิตทั้งหมดส่งคืน 0 นี่ถือเป็นบล็อกที่เตรียมไว้อย่างดี สิ่งที่ยอดเยี่ยมก็คือหากเราสลับบิตใดบิตหนึ่งในรายการนี้ จำลองข้อผิดพลาดแบบสุ่มจากสัญญาณรบกวน จากนั้นหากคุณเรียกใช้โค้ดบรรทัดเดียวกัน มันจะพิมพ์ข้อผิดพลาดนั้นออกมา นั่นไม่เรียบร้อยเหรอ? ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -568,7 +568,7 @@
   "end": 589.44
  },
  {
-  "input": "So at the moment it looks like if we do this on our random block of 16 bits, it returns 9, which has the binary representation 1001. ",
+  "input": "So at the moment it looks like if we do this on our random block of 16 bits, it returns 9, which has the binary representation 1001.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0. ",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -584,7 +584,7 @@
   "end": 615.46
  },
  {
-  "input": "This would be considered a well-prepared block. ",
+  "input": "This would be considered a well-prepared block.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. ",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -600,7 +600,7 @@
   "end": 630.22
  },
  {
-  "input": "an error that changes a 1 to a 0. You see, if you add a bit string together twice, it's the same as ",
+  "input": "Isn't that neat?",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any. ",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -616,7 +616,7 @@
   "end": 641.06
  },
  {
-  "input": "And that effect, again, is that the total result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me sh ",
+  "input": "And there's nothing special about the size 16 here.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -624,7 +624,7 @@
   "end": 645.2
  },
  {
-  "input": "The same line of code would work if you had a list of, say, 256 bits. ",
+  "input": "The same line of code would work if you had a list of, say, 256 bits.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -632,7 +632,7 @@
   "end": 649.86
  },
  {
-  "input": "ferenced before, which will capture almost all of the logic on the receiver's end. We'll start by creating a random array of 16 ones and zeros to simulate the data block, and I'll go ahead and give it the name bits, but of course in practice this would be something that we're receiving f ",
+  "input": "Needless to say, there is more code to write here, like doing the meta parity check to detect 2-bit errors, but the idea is that almost all of the core logic from our scheme comes down to a single XOR reduction.",
   "translatedText": "คุณสามารถดึงบล็อกนี้ขึ้นมาใหม่ รันบรรทัดเดียวบนบล็อกนั้น และมันจะแยกตำแหน่งของข้อผิดพลาดออกโดยอัตโนมัติ หรือจะเป็น 0 หากไม่มีเลย และไม่มีอะไรพิเศษเกี่ยวกับไซส์ 16 ที่นี่ โค้ดบรรทัดเดียวกันนี้จะใช้ได้ถ้าคุณมีรายการ เช่น 256 บิต ไม่จำเป็นต้องพูดว่า มีโค้ดให้เขียนมากกว่านี้ เช่น การตรวจสอบเมตาพาริตี้เพื่อตรวจจับข้อผิดพลาด 2 บิต แต่แนวคิดก็คือตรรกะหลักเกือบทั้งหมดจากโครงการของเราลดลงเหลือเพียงการลด XOR เพียงครั้งเดียว ตอนนี้ ขึ้นอยู่กับความสะดวกสบายของคุณกับไบนารี่และ XOR และซอฟต์แวร์โดยทั่วไป คุณอาจพบว่ามุมมองนี้สับสนเล็กน้อย หรือหรูหราและเรียบง่ายกว่านั้นมากจนคุณสงสัยว่าทำไมเราไม่เพียงแค่เริ่มต้นจากจุดเริ่มต้น -ไป. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. ",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level. ",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -656,7 +656,7 @@
   "end": 690.5
  },
  {
-  "input": "l out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on. In this case it looks like those positions are 0, 4, 6, 9, etc. Remember, what ",
+  "input": "The first one is easiest to actually do by hand, and I think it does a better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the log of the size of the block, or in other words, it grows one bit at a time as the block size doubles.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "we want is to collect together all of those positions, the positions of the bits that are turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. ",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -672,7 +672,7 @@
   "end": 716.06
  },
  {
-  "input": "That's really what runs against most people's knee-jerk reaction when they first think about making a message resilient to errors, where usually copying the whole message is the first instinct that comes to mind. ",
+  "input": "That's really what runs against most people's knee-jerk reaction when they first think about making a message resilient to errors, where usually copying the whole message is the first instinct that comes to mind.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix. ",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -688,7 +688,7 @@
   "end": 734.0
  },
  {
-  "input": "It's kind of nice because it relates it to the broader family of linear codes, but I think that gives almost no intuition for where it comes from or how it scales. ",
+  "input": "It's kind of nice because it relates it to the broader family of linear codes, but I think that gives almost no intuition for where it comes from or how it scales.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. ",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "looks like if we do this on our random block of 16 bits, it returns 9, which has the binary representation 1001. We won't do it here, but you could write a function wh ",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "พูดง่ายๆ ก็คือ มุมมองการตรวจสอบความเท่าเทียมกันหลายรายการจะคิดได้ง่ายกว่าเมื่อใช้โค้ด Hamming ในฮาร์ดแวร์โดยตรง และมุมมอง XOR นั้นคิดได้ง่ายที่สุดเมื่อทำในซอฟต์แวร์จากระดับที่สูงกว่า วิธีแรกนั้นง่ายที่สุดที่ทำด้วยมือจริง ๆ และฉันคิดว่ามันจะทำงานได้ดีกว่าโดยปลูกฝังสัญชาตญาณหลักที่เป็นรากฐานทั้งหมดนี้ ซึ่งก็คือข้อมูลที่จำเป็นต้องใช้ในการค้นหาข้อผิดพลาดเดียวนั้นเกี่ยวข้องกับบันทึกขนาดของบล็อก หรืออีกนัยหนึ่ง มันจะขยายทีละบิตเมื่อขนาดบล็อกเพิ่มขึ้นสองเท่า ข้อเท็จจริงที่เกี่ยวข้องในที่นี้คือข้อมูลนั้นสอดคล้องโดยตรงกับปริมาณความซ้ำซ้อนที่เราต้องการ  นั่นคือสิ่งที่ขัดแย้งกับปฏิกิริยากระตุกเข่าของคนส่วนใหญ่เมื่อพวกเขาคิดถึงการสร้างข้อความที่ยืดหยุ่นต่อข้อผิดพลาด ซึ่งโดยปกติแล้วการคัดลอกข้อความทั้งหมดถือเป็นสัญชาตญาณแรกที่เข้ามาในใจ  แล้ว ยังมีอีกวิธีหนึ่ง ที่บางครั้งคุณจะเห็นโค้ดแฮมมิงนำเสนอ โดยคุณคูณข้อความด้วยเมทริกซ์ขนาดใหญ่ตัวเดียว เป็นเรื่องดีเพราะมันเกี่ยวข้องกับกลุ่มโค้ดเชิงเส้นที่กว้างกว่า แต่ฉันคิดว่านั่นแทบไม่ได้ให้สัญชาตญาณเลยว่ามันมาจากไหนหรือปรับขนาดอย่างไร และเมื่อพูดถึงการปรับขนาด คุณอาจสังเกตเห็นว่าประสิทธิภาพของโครงร่างนี้จะดีขึ้นเมื่อเราเพิ่มขนาดบล็อกเท่านั้น ตัวอย่างเช่น เราเห็นว่าด้วย 256 บิต คุณใช้พื้นที่เพียง 3% ของพื้นที่นั้นในการสำรอง และมันจะดีขึ้นเรื่อยๆ จากจุดนั้น เมื่อจำนวนบิตพาริตีเพิ่มขึ้นทีละบิต ขนาดบล็อกก็จะเพิ่มขึ้นเป็นสองเท่า และถ้าคุณใช้มันสุดโต่ง คุณสามารถมีบล็อกที่มีหนึ่งล้านบิต ซึ่งคุณคงจะเล่นคำถาม 20 ข้อกับการตรวจสอบพาริตีของคุณ และมันใช้เพียง 21 พาริตีบิตเท่านั้น และถ้าคุณย้อนกลับไปคิดถึงการดูล้านบิตและค้นหาข้อผิดพลาดเพียงจุดเดียว นั่นคงรู้สึกบ้าไปแล้วจริงๆ แน่นอนว่าปัญหาก็คือ เมื่อมีบล็อกขนาดใหญ่ ความน่าจะเป็นที่จะเห็นข้อผิดพลาดมากกว่าหนึ่งหรือสองบิตก็จะเพิ่มขึ้น และโค้ด Hamming ก็ไม่สามารถจัดการอะไรนอกเหนือจากนั้นได้ ในทางปฏิบัติ สิ่งที่คุณต้องการคือการหาขนาดที่เหมาะสม เพื่อไม่ให้ความน่าจะเป็นที่จะพลิกบิตมากเกินไป นอกจากนี้ ในทางปฏิบัติ ข้อผิดพลาดมักจะเกิดขึ้นเป็นชุดเล็กๆ น้อยๆ ซึ่งจะทำให้บล็อกเดียวเสียหายโดยสิ้นเชิง ดังนั้นกลวิธีทั่วไปประการหนึ่งที่จะช่วยกระจายข้อผิดพลาดแบบต่อเนื่องไปยังบล็อกต่างๆ มากมายคือการสอดประสานบล็อกเหล่านั้น เช่นนี้ ก่อนที่จะ ส่งหรือเก็บไว้ อีกครั้ง สิ่งเหล่านี้ส่วนใหญ่ถูกโต้แย้งอย่างสมบูรณ์ด้วยโค้ดที่ทันสมัยกว่า เช่น อัลกอริธึม Reed-Solomon ที่ใช้กันทั่วไปมากกว่า ซึ่งจัดการข้อผิดพลาดแบบ Burst ได้ดีเป็นพิเศษ และสามารถปรับให้มีความยืดหยุ่นต่อจำนวนข้อผิดพลาดที่มากขึ้นต่อบล็อก . ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ere the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a state where running th ",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits. ",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -728,7 +728,7 @@
   "end": 780.02
  },
  {
-  "input": "And if you step back to think about looking at a million bits and locating a single error, that genuinely feels crazy. ",
+  "input": "And if you step back to think about looking at a million bits and locating a single error, that genuinely feels crazy.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that. ",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -744,7 +744,7 @@
   "end": 797.66
  },
  {
-  "input": "So in practice, what you'd want is to find the right size so that the probability of too many bit flips isn't too high. ",
+  "input": "So in practice, what you'd want is to find the right size so that the probability of too many bit flips isn't too high.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -752,7 +752,7 @@
   "end": 804.3
  },
  {
-  "input": "imulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the positio ",
+  "input": "Also, in practice, errors tend to come in little bursts, which would totally ruin a single block, so one common tactic to help spread out a burst of errors across many different blocks is to interlace those blocks, like this, before they're sent out or stored.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -760,7 +760,7 @@
   "end": 820.98
  },
  {
-  "input": "Then again, a lot of this is rendered completely moot by more modern codes, like the much more commonly used Reed-Solomon algorithm, which handles burst errors particularly well, and it can be tuned to be resilient to a larger number of errors per block. ",
+  "input": "Then again, a lot of this is rendered completely moot by more modern codes, like the much more commonly used Reed-Solomon algorithm, which handles burst errors particularly well, and it can be tuned to be resilient to a larger number of errors per block.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "But that's a topic for another time. ",
+  "input": "But that's a topic for another time.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was. ",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -784,7 +784,7 @@
   "end": 849.94
  },
  {
-  "input": "He first tried all sorts of different schemes involving organizing the bits into parts of a higher dimensional lattice and strange things like this. ",
+  "input": "He first tried all sorts of different schemes involving organizing the bits into parts of a higher dimensional lattice and strange things like this.",
   "translatedText": "แต่นั่นเป็นหัวข้อสำหรับอีกครั้ง ในหนังสือของเขา The Art of Doing Science and Engineering แฮมมิงเปิดเผยอย่างตรงไปตรงมาว่าการค้นพบรหัสนี้คดเคี้ยวเพียงใด ขั้นแรกเขาลองใช้แผนงานต่างๆ มากมายที่เกี่ยวข้องกับการจัดชิ้นส่วนให้เป็นส่วนหนึ่งของโครงตาข่ายมิติที่สูงกว่าและสิ่งแปลกประหลาดเช่นนี้ ความคิดที่ว่าอาจเป็นไปได้ที่จะได้รับการตรวจสอบความเท่าเทียมกันเพื่อสมรู้ร่วมคิดในลักษณะที่สะกดตำแหน่งของข้อผิดพลาดเท่านั้นที่มาถึงแฮมมิงเมื่อเขาก้าวถอยหลังหลังจากการวิเคราะห์อื่น ๆ มากมายและถามว่าโอเคอะไรคือสิ่งที่มีประสิทธิภาพมากที่สุดที่ฉันสามารถทำได้ คงจะเกี่ยวกับเรื่องนี้ใช่ไหม? ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -792,7 +792,7 @@
   "end": 857.78
  },
  {
-  "input": "The idea that it might be possible to get parity checks to conspire in a way that spells out the position of an error only came to Hamming when he stepped back after a bunch of other analysis and asked, okay, what is the most efficient I could conceivably be about this? ",
+  "input": "The idea that it might be possible to get parity checks to conspire in a way that spells out the position of an error only came to Hamming when he stepped back after a bunch of other analysis and asked, okay, what is the most efficient I could conceivably be about this?",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -800,7 +800,7 @@
   "end": 871.52
  },
  {
-  "input": "He was also candid about how important it was that parity checks were already on his mind, which would have been way less common back in the 1940s than it is today. ",
+  "input": "He was also candid about how important it was that parity checks were already on his mind, which would have been way less common back in the 1940s than it is today.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "is perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it ",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -816,7 +816,7 @@
   "end": 888.22
  },
  {
-  "input": "Clever ideas often look deceptively simple in hindsight, which makes them easy to underappreciate. ",
+  "input": "Clever ideas often look deceptively simple in hindsight, which makes them easy to underappreciate.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -824,7 +824,7 @@
   "end": 894.3
  },
  {
-  "input": "Right now my honest hope is that Hamming codes, or at least the possibility of such codes, feels almost obvious to you. ",
+  "input": "Right now my honest hope is that Hamming codes, or at least the possibility of such codes, feels almost obvious to you.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't. ",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -840,7 +840,7 @@
   "end": 906.82
  },
  {
-  "input": ", with four yes or no questions, we have 16 possible outcomes for our parity checks, and at first that feels perfect for pinpointing 1 out of 16 positions in the block, but you also need to communicate a 17th outcome, the no error condition. The first one is easiest to actually do by hand, and I think it does a better job instilling the core intuition underlying all of this, ",
+  "input": "Part of the reason that clever ideas look deceptively easy is that we only ever see the final result, cleaning up what was messy, never mentioning all of the wrong turns, underselling just how vast the space of explorable possibilities is at the start of a problem solving process, all of that.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -848,7 +848,7 @@
   "end": 922.86
  },
  {
-  "input": "which is that the information required to locate a single error is relat ",
+  "input": "But this is true in general.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -856,7 +856,7 @@
   "end": 924.9
  },
  {
-  "input": "ed to the log of the size of the block, or in other words, it grows one bit at a time as the block size doubles. The relevant fact here i ",
+  "input": "I think for some special inventions, there's a second, deeper reason that we underappreciate them.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -864,7 +864,7 @@
   "end": 930.04
  },
  {
-  "input": "Thinking of information in terms of bits had only really coalesced into a full theory by 1948, with Claude Shannon's seminal paper on information theory. ",
+  "input": "Thinking of information in terms of bits had only really coalesced into a full theory by 1948, with Claude Shannon's seminal paper on information theory.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -872,7 +872,7 @@
   "end": 938.64
  },
  {
-  "input": "block is even, just like a normal parity check. Now, if there's a single bit error, then ",
+  "input": "This was essentially concurrent with when Hamming developed his algorithm.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "the parity of the full block toggles to be odd, but we would catch that anyway thanks to the four error-correcting checks. However, if there's two errors, then the overall parity is going to toggle back to be And then, by the way, there is this whole other way that you s ",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -888,7 +888,7 @@
   "end": 952.9
  },
  {
-  "input": "Shannon and Hamming, by the way, shared an office in Bell Labs, despite working on very different things, which hardly seems coincidental here. ",
+  "input": "Shannon and Hamming, by the way, shared an office in Bell Labs, despite working on very different things, which hardly seems coincidental here.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "multiply the message by one big matrix. It's kind of nice because it relates it to the broader family of linear codes, but I think that gives almost no intuition for where it comes from or how it scales. ",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -904,7 +904,7 @@
   "end": 972.34
  },
  {
-  "input": "Ironically, the ideas that most profoundly shape the ways that a future generation thinks will end up looking to that future generation simpler than they really are. ",
+  "input": "Ironically, the ideas that most profoundly shape the ways that a future generation thinks will end up looking to that future generation simpler than they really are.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/turkish/sentence_translations.json b/2020/hamming-codes-2/turkish/sentence_translations.json
index eeb3f8b35..30c70f42a 100644
--- a/2020/hamming-codes-2/turkish/sentence_translations.json
+++ b/2020/hamming-codes-2/turkish/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "Bitlerin çoğunun anlamlı bir mesaj taşıdığı, diğer birkaç parçanın ise bir tür artıklık işlevi gördüğü bir veri bloğu oluşturmanın bir yolu olan Hamming kodlarından bahsediyorduk; herhangi bir bit ters çevrildiğinde ya bir mesaj Bit veya artıklık biti, bu bloktaki herhangi bir şeyde, alıcı bir hata olduğunu ve bunun nasıl düzeltileceğini tanımlayabilecektir.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "Orada sunulan temel fikir, hataya giden yolda ikili arama yapmak için çoklu eşlik kontrolünün nasıl kullanılacağıydı.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "Örneğin, ikili sistemde 7 sayısı 0111'e benzer, aslında 4 artı 2 artı 1 olduğunu söyler.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "Ve 7. pozisyonun nerede olduğuna dikkat edin, bu durum eşitlik gruplarımızın birincisini, ikincisini ve üçüncüsünü etkiliyor, ancak sonuncusunu etkilemiyor.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "Yani bu dört kontrolün sonuçlarını aşağıdan yukarıya doğru okumak gerçekten de hatanın konumunu ortaya koyuyor.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "Bu ikili etiketleri kutularına geri koyarken, bunların gerçekte gönderilen verilerden farklı olduklarını vurgulamam gerekiyor.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "Bunlar sizin ve benim dört eşitlik grubunun nereden geldiğini anlamamıza yardımcı olacak kavramsal bir etiketten başka bir şey değil.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "Baktığımız her şeyin ikili olarak tanımlanmasının zarafeti, belki de baktığımız her şeyin ikili olarak tanımlanmasının yarattığı kafa karışıklığı nedeniyle gölgede kalıyor.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "Elde ettiğimiz şey, dört eşlik grubumuzun ilkidir; bu, ilk kontrolü şu soruyla yorumlayabileceğiniz anlamına gelir: hey, eğer bir hata varsa, bu hatanın konumundaki son bit 1 mi?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "Ve benzeri.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "Birincisi, ikinin daha büyük kuvvetleri olan blok boyutlarına sistematik olarak nasıl genelleştirme yapılacağıdır.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "Bunun anlamı, bu eşlik bitlerinin her birinin, dört eşlik grubundan yalnızca birinin içinde yer almasıdır.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "İki bitin XOR'unu aldığınızda, bu bitlerden herhangi biri açıksa 1 değerini döndürür, ancak her ikisi de açık veya kapalıysa bu sonuç değişmez.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "Farklı bir ifadeyle bu iki bitin paritesidir.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "Toplama gibi ama asla taşımadığınız yer.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "Sizin ve benim için kilit nokta, birçok farklı bit dizisinin XOR'unu almanın, sütunlarda olduğu gibi bir grup ayrı grubun parodilerini tek bir hamlede etkili bir şekilde hesaplamanın bir yolu olmasıdır.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "Bu bize, Hamming kod algoritmamızın çoklu eşlik kontrollerinin tek bir işlemde paketlenmesi hakkında düşünmemiz için oldukça şık bir yol sağlıyor.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "bu mantıklı mı?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "Benzer şekilde, bir sonraki sütun, ikinci eşlik grubunda kaç konumun bulunduğunu, ikinciden sondan biti 1 olan ve hangilerinin vurgulandığını vb. sayar.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "Şimdi bu şekilde elde ettiğimizde, bu bize, alttaki sonuçta ortaya çıkan dört bitin neden doğrudan bir hatanın konumunu gösterdiğini düşünmemiz için gerçekten güzel bir yol sağlıyor.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "Diyelim ki bu bloktaki bir bit 0'dan 1'e değiştirildi.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "Bunun anlamı, o bitin konumu artık toplam XOR'a dahil edilecek, bu da toplamı 0'dan yeni eklenen değere, yani hatanın konumuna dönüştürecek.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "Veri bloğunu simüle etmek için 16 1 ve 0'lardan oluşan rastgele bir dizi oluşturarak başlayacağız ve ona bitlerin adını vereceğim, ancak elbette pratikte bu, bir göndericiden aldığımız bir şey olacaktır ve bunun yerine rastgele olduğundan 5 eşlik bitiyle birlikte 11 veri biti taşıyor olacaktır.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "Yani eğer daha sonra tüm bu çiftleri, i'ye benzeyen çiftleri kapsayan bir liste oluşturursak ve sonra sadece i değerini, sadece indeksi çıkarırsak, bu o kadar da heyecan verici değil, sadece 0'dan 15'e kadar olan indeksleri geri alırız.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "Ancak bunu yalnızca if biti yapma koşulunu eklersek, yani bu bit 0 değil de 1 ise, o zaman yalnızca karşılık gelen bitin açık olduğu konumları çeker.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "Bunu burada yapmayacağız, ancak gönderenin, dört eşlik bitini gerektiği gibi ayarlamak için bu ikili gösterimi kullandığı ve sonuçta bu bloğu, bu kod satırını bitlerin tam listesinde çalıştırmanın geri döndüğü bir duruma getirdiği bir fonksiyon yazabilirsiniz. bir 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "İşin güzel yanı, bu listedeki bitlerden herhangi birini değiştirirsek, gürültüden kaynaklanan rastgele bir hatayı simüle edersek, o zaman aynı kod satırını çalıştırırsanız, o hatayı yazdırır.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "Bu bloğu birdenbire alabilir, üzerinde bu tek satırı çalıştırabilirsiniz ve otomatik olarak bir hatanın konumunu veya eğer yoksa 0'ı söyler.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "Şimdi, ikili ve XOR'lar ve genel olarak yazılım konusundaki rahatınıza bağlı olarak, bu bakış açısını ya biraz kafa karıştırıcı bulabilir ya da çok daha şık ve basit bulabilir ve neden en baştan bununla başlamadığımızı merak edebilirsiniz. -Gitmek.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "Kabaca konuşursak, çoklu eşlik kontrolü perspektifini, Hamming kodlarını donanıma doğrudan uygularken düşünmek daha kolaydır ve XOR perspektifini, bunu yazılımda yaparken, daha yüksek bir seviyeden düşünmek en kolayıdır.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "Buradaki ilgili gerçek şu ki, bu bilgi doğrudan ne kadar fazlalığa ihtiyacımız olduğuna karşılık geliyor.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "Ve bu arada, bazen Hamming kodlarının sunulduğunu gördüğünüz, mesajı büyük bir matrisle çarptığınız tamamen farklı bir yol daha var.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "Ölçeklendirmeden bahsetmişken, blok boyutunu artırdıkça bu planın verimliliğinin de arttığını fark edebilirsiniz.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "Örneğin, 256 bit ile bu alanın yalnızca %3'ünü yedeklilik için kullandığınızı ve bu noktadan sonra giderek daha iyi hale geldiğini gördük.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "Eşlik bitlerinin sayısı birer birer arttıkça blok boyutu da iki katına çıkar.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "Ve eğer bunu aşırıya götürürseniz, diyelim ki bir milyon bitlik bir bloğunuz olabilir, burada kelimenin tam anlamıyla eşlik kontrollerinizle 20 soru oynuyorsunuz ve bu blok yalnızca 21 eşlik biti kullanıyor.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "Sorun, elbette, daha büyük bir blokla, bir veya iki bitten daha fazla hata görme olasılığının artması ve Hamming kodlarının bunun ötesinde hiçbir şeyi ele almamasıdır.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "Ama bu başka bir zamanın konusu.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "Hamming, The Art of Doing Science and Engineering adlı kitabında bu kodu keşfetmesinin ne kadar dolambaçlı olduğunu son derece samimi bir şekilde anlatıyor.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "Bu kitap boyunca neredeyse yarım düzine kez Louis Pasteur'ün bir sözüne gönderme yapıyor; şans hazırlıklı bir zihinden yanadır.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "Ancak bunların aslında bariz olduğunu düşünerek kendinizi kandırmamalısınız çünkü kesinlikle öyle değiller.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "Bu, en azından teoride, bit kayması olasılığı ne kadar yüksek olursa olsun, bir anlamda etkili hata düzeltmenin her zaman mümkün olduğunu gösteren aynı temel makaleydi.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "Birkaç on yıl ileri saralım ve bu günlerde çoğumuz küçük parçalar ve bilgiler üzerine düşünmeye o kadar dalmış durumdayız ki, bu düşünce tarzının ne kadar farklı olduğunu gözden kaçırmak çok kolay.",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/ukrainian/sentence_translations.json b/2020/hamming-codes-2/ukrainian/sentence_translations.json
index e9822e9fe..7c9c54af4 100644
--- a/2020/hamming-codes-2/ukrainian/sentence_translations.json
+++ b/2020/hamming-codes-2/ukrainian/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "Ми говорили про коди Хеммінга, спосіб створення блоку даних, де більшість бітів несуть значуще повідомлення, тоді як кілька інших діють як свого роду надлишковість, таким чином, що якщо будь-який біт перевертається, або повідомлення біт або біт надлишковості, будь-що в цьому блоці, приймач зможе визначити, що була помилка, і як її виправити.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "Основна ідея, представлена там, полягала в тому, як використовувати кілька перевірок на парність для бінарного пошуку на шляху до помилки.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "Наприклад, число 7 у двійковій системі виглядає як 0111, по суті кажучи, що це 4 плюс 2 плюс 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "І зауважте, де знаходиться позиція 7, вона дійсно впливає на першу з наших груп парності, і на другу, і на третю, але не на останню.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "Отже, читання результатів цих чотирьох перевірок знизу вгору справді пояснює місце помилки.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "Коли ми повертаємо ці двійкові мітки назад у свої коробки, дозвольте мені підкреслити, що вони відрізняються від даних, які насправді надсилаються.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "Вони не що інше, як концептуальний ярлик, який допоможе вам і мені зрозуміти, звідки взялися чотири паритетні групи.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "Елегантність того, що все, на що ми дивимося, описується у двійковому форматі, можливо, підривається плутаниною, пов’язаною з тим, що все, на що ми дивимося, описується у двійковому форматі.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "Що ми отримуємо, це перша з наших чотирьох груп парності, що означає, що ви можете інтерпретувати цю першу перевірку як запитання: якщо є помилка, чи є останній біт у позиції цієї помилки 1?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "І так далі.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "По-перше, як систематично узагальнювати розміри блоків, які є більшими степенями двійки.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "Це означає, що кожен із цих бітів парності знаходиться в одній і лише одній із чотирьох груп парності.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "Коли ви використовуєте XOR двох бітів, він повертає 1, якщо один із цих бітів увімкнено, але не якщо обидва увімкнено чи вимкнено.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "Іншими словами, це парність цих двох бітів.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "Це як доповнення, але куди ніколи не понесеш.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "Ключовим моментом для нас із вами є те, що використання XOR багатьох різних бітових рядків є ефективним способом обчислення пародії на купу окремих груп, як і зі стовпцями, одним махом.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "Це дає нам досить хитрий спосіб уявити, що численні перевірки парності з нашого алгоритму коду Хеммінга об’єднані в одну операцію.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "Чи має це сенс?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "Подібним чином у наступному стовпці підраховується кількість позицій у другій групі парності, позиції, передостанній біт яких дорівнює 1, які також виділені тощо.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "Тепер, коли ми маємо це таким чином, це дає нам дійсно гарний спосіб подумати про те, чому ці чотири результуючих біта внизу безпосередньо вказують на місце помилки.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "Припустимо, якийсь біт у цьому блоці перемикається з 0 на 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "Це означає, що позиція цього біта тепер буде включена в загальне XOR, яке змінює суму з 0 на це нове включене значення, позицію помилки.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "Ми почнемо зі створення випадкового масиву з 16 1 і 0 для імітації блоку даних, і я дам йому біти назви, але, звичайно, на практиці це буде щось, що ми отримуємо від відправника, а замість будучи випадковим, він містив би 11 біт даних разом із 5 бітами парності.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "Отже, якщо ми створимо список, який циклічно перебирає всі ці пари, пари, які виглядають як i, а потім витягуємо лише значення i, лише індекс, це не так цікаво, ми просто повертаємо ті індекси від 0 до 15.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "Але якщо ми додамо умову робити це тільки якщо біт, тобто якщо цей біт є 1, а не 0, добре, тоді він вилучає лише ті позиції, де відповідний біт увімкнено.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "Ми не будемо цього робити тут, але ви можете написати функцію, у якій відправник використовує це двійкове представлення, щоб за потреби встановити чотири біти парності, зрештою переводячи цей блок у стан, коли виконання цього рядка коду з повним списком бітів повертає а 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "Цікаво те, що якщо ми перемикаємо будь-який із бітів у цьому списку, імітуючи випадкову помилку через шум, тоді, якщо ви запустите цей самий рядок коду, він виведе цю помилку.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "Ви можете отримати цей блок зненацька, запустити на ньому цей єдиний рядок, і він автоматично видасть позицію помилки або 0, якщо її не було.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "Тепер, залежно від вашого комфорту з двійковими кодами та XOR та програмним забезпеченням загалом, ви можете або вважати цю перспективу трохи заплутаною, або настільки більш елегантною та простою, що ви дивуєтеся, чому ми не почали з неї з самого початку -іди.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "Грубо кажучи, про перспективу множинної перевірки парності легше подумати, якщо реалізовувати коди Хеммінга в апаратному забезпеченні дуже безпосередньо, а про перспективу XOR найпростіше подумати, роблячи це в програмному забезпеченні, на більш високому рівні.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "Релевантним фактом тут є те, що ця інформація безпосередньо відповідає тому, скільки резервування нам потрібно.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "І, до речі, є цілий інший спосіб, у який ви іноді бачите представлені коди Хеммінга, коли ви множите повідомлення на одну велику матрицю.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "Говорячи про масштабування, ви можете помітити, що ефективність цієї схеми стає лише кращою, коли ми збільшуємо розмір блоку.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "Наприклад, ми бачили, що з 256 бітами ви використовуєте лише 3% цього простору для резервування, і з цього моменту все стає краще.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "Оскільки кількість бітів парності зростає один за одним, розмір блоку продовжує подвоюватися.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "І якщо ви доведете це до крайності, у вас може бути блок, скажімо, з мільйоном біт, де ви б буквально відтворювали 20 запитань із перевіркою парності, і він використовує лише 21 біт парності.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "Проблема, звісно, полягає в тому, що з більшим блоком зростає ймовірність побачити більше однієї або двох бітових помилок, а коди Хеммінга не обробляють нічого, крім цього.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "Але це тема іншого разу.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "У своїй книзі «Мистецтво займатися наукою та технікою» Хеммінг надзвичайно відверто розповідає про те, наскільки звивистим було його відкриття цього коду.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "У цій книзі він півдюжини разів посилається на цитату Луї Пастера: удача сприяє підготовленому розуму.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "Але ви не повинні обманювати себе, думаючи, що вони насправді очевидні, тому що це точно не так.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "Це був той самий основоположний документ, який показав, у певному сенсі, що ефективне виправлення помилок завжди можливе, незалежно від того, наскільки висока ймовірність перевертань бітів, принаймні в теорії.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "Перемотуємо вперед на кілька десятиліть, і сьогодні багато з нас настільки занурені в роздуми про біти та інформацію, що легко не помітити, наскільки відмінним був цей спосіб мислення.",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/urdu/sentence_translations.json b/2020/hamming-codes-2/urdu/sentence_translations.json
index 75805b24b..06d9be148 100644
--- a/2020/hamming-codes-2/urdu/sentence_translations.json
+++ b/2020/hamming-codes-2/urdu/sentence_translations.json
@@ -1,6 +1,6 @@
 [
  {
-  "input": "I'm assuming that everybody here is coming from part 1. ",
+  "input": "I'm assuming that everybody here is coming from part 1.",
   "translatedText": "میں فرض کر رہا ہوں کہ یہاں ہر کوئی حصہ 1 سے آ رہا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it. ",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "ہم ہیمنگ کوڈز کے بارے میں بات کر رہے تھے، ڈیٹا کا ایک بلاک بنانے کا ایک طریقہ جہاں زیادہ تر بٹس ایک بامعنی پیغام لے جاتے ہیں، جب کہ کچھ دوسرے ایک قسم کی فالتو پن کے طور پر کام کرتے ہیں، اس طرح کہ اگر کوئی بٹ پلٹ جائے، یا تو ایک پیغام۔bit یا redundancy bit، اس بلاک میں کوئی بھی چیز، وصول کنندہ اس قابل ہو جائے گا کہ یہ شناخت کر سکے کہ کوئی خرابی تھی، اور اسے کیسے ٹھیک کیا جائے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error. ",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "وہاں پیش کیا گیا بنیادی خیال یہ تھا کہ غلطی تک پہنچنے کے لیے بائنری تلاش کرنے کے لیے متعدد برابری چیک کا استعمال کیسے کریں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -24,7 +24,7 @@
   "end": 27.16
  },
  {
-  "input": "In that video the goal was to make Hamming codes feel as hands-on and rediscoverable as possible. ",
+  "input": "In that video the goal was to make Hamming codes feel as hands-on and rediscoverable as possible.",
   "translatedText": "اس ویڈیو میں مقصد ہیمنگ کوڈز کو ممکنہ حد تک ہینڈ آن اور دوبارہ دریافت کرنے کا احساس دلانا تھا۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -32,7 +32,7 @@
   "end": 34.6
  },
  {
-  "input": "hat there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error. In that video, the goal was to make Hamming codes feel as hands-on and rediscoverable as possible. But as ",
+  "input": "But as you start to think about actually implementing this, either in software or hardware, that framing may actually undersell how elegant these codes really are.",
   "translatedText": "لیکن جیسے ہی آپ سافٹ ویئر یا ہارڈ ویئر میں اس کو عملی جامہ پہنانے کے بارے میں سوچنا شروع کر دیتے ہیں، وہ فریمنگ حقیقت میں اس بات کو کم کر سکتی ہے کہ یہ کوڈز واقعی کتنے خوبصورت ہیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -40,7 +40,7 @@
   "end": 43.46
  },
  {
-  "input": "You might think that you need to write an algorithm that keeps track of all the possible error locations and cuts that group in half with each check, but it's actually way, way simpler than that. ",
+  "input": "You might think that you need to write an algorithm that keeps track of all the possible error locations and cuts that group in half with each check, but it's actually way, way simpler than that.",
   "translatedText": "آپ سوچ سکتے ہیں کہ آپ کو ایک الگورتھم لکھنے کی ضرورت ہے جو غلطی کے تمام ممکنہ مقامات پر نظر رکھے اور ہر چیک کے ساتھ اس گروپ کو نصف میں کاٹ دے، لیکن یہ حقیقت میں اس سے کہیں زیادہ آسان طریقہ ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -48,7 +48,7 @@
   "end": 53.48
  },
  {
-  "input": "If you read out the answers to the four parity checks we did in the last video, all as 1s and 0s instead of yeses and nos, it literally spells out the position of the error in binary. ",
+  "input": "If you read out the answers to the four parity checks we did in the last video, all as 1s and 0s instead of yeses and nos, it literally spells out the position of the error in binary.",
   "translatedText": "اگر آپ پچھلی ویڈیو میں ہم نے جو چار برابری کی جانچ پڑتال کی تھی، ان کے جوابات پڑھتے ہیں، جیسے کہ yeses اور nos کے بجائے 1s اور 0s، یہ لفظی طور پر بائنری میں غلطی کی پوزیشن کو واضح کرتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "you read out the answers to the four parity checks we did in the last video, all as ones and zeros instead of yeses and nos, it literally spells out ",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "مثال کے طور پر، بائنری میں نمبر 7 0111 کی طرح لگتا ہے، بنیادی طور پر یہ کہہ رہا ہے کہ یہ 4 جمع 2 جمع 1 ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last. ",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "اور دیکھیں کہ پوزیشن 7 کہاں بیٹھتی ہے، یہ ہمارے برابری گروپوں میں سے پہلے کو متاثر کرتی ہے، اور دوسرے، اور تیسرے کو، لیکن آخری نہیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day. The goal here is to give you a very thorough understanding of one of the earlie ",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "لہذا نیچے سے اوپر تک ان چار چیکوں کے نتائج کو پڑھنا واقعی غلطی کی پوزیشن کو واضح کرتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -80,7 +80,7 @@
   "end": 87.54
  },
  {
-  "input": "st examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity groups, and the second, and the third, but not the last. So reading the results of those four checks ",
+  "input": "There's nothing special about the example 7, this works in general, and this makes the logic for implementing the whole scheme in hardware shockingly simple.",
   "translatedText": "مثال 7 کے بارے میں کچھ خاص نہیں ہے، یہ عام طور پر کام کرتا ہے، اور یہ ہارڈ ویئر میں پوری اسکیم کو لاگو کرنے کی منطق کو حیران کن حد تک آسان بنا دیتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -88,7 +88,7 @@
   "end": 95.82
  },
  {
-  "input": "Now if you want to see why this magic happens, take these 16 index labels for our positions, but instead of writing them in base 10, let's write them all in binary, running from 0000 up to 1111. ",
+  "input": "Now if you want to see why this magic happens, take these 16 index labels for our positions, but instead of writing them in base 10, let's write them all in binary, running from 0000 up to 1111.",
   "translatedText": "اب اگر آپ یہ دیکھنا چاہتے ہیں کہ یہ جادو کیوں ہوتا ہے، تو ان 16 انڈیکس لیبلز کو ہماری پوزیشنوں کے لیے لیں، لیکن ان کو بیس 10 میں لکھنے کے بجائے، آئیے ان سب کو بائنری میں لکھیں، جو 0000 سے 1111 تک چلتے ہیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent. ",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "جیسا کہ ہم ان بائنری لیبلز کو ان کے خانوں میں واپس ڈالتے ہیں، میں اس بات پر زور دیتا ہوں کہ وہ اصل میں بھیجے جانے والے ڈیٹا سے الگ ہیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from. ",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "وہ ایک تصوراتی لیبل سے زیادہ کچھ نہیں ہیں جو آپ اور مجھے یہ سمجھنے میں مدد کرتے ہیں کہ چار برابری والے گروپ کہاں سے آئے ہیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary. ",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "ہر وہ چیز جس کو ہم بائنری میں بیان کر رہے ہیں اس کی خوبصورتی شاید بائنری میں بیان کیے جانے والے ہر چیز کے ہونے کی الجھن کی وجہ سے کم ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -120,7 +120,7 @@
   "end": 132.36
  },
  {
-  "input": "0, let's write them all in binary, running from 0000 up to 1111. ask feels at the star ",
+  "input": "It's worth it, though.",
   "translatedText": "یہ اس کے قابل ہے، اگرچہ. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -128,7 +128,7 @@
   "end": 134.12
  },
  {
-  "input": "Focus your attention just on that last bit of all of these labels, and then highlight the positions where that final bit is a 1. ",
+  "input": "Focus your attention just on that last bit of all of these labels, and then highlight the positions where that final bit is a 1.",
   "translatedText": "اپنی توجہ صرف ان تمام لیبلز کے آخری بٹ پر مرکوز کریں، اور پھر ان پوزیشنوں کو نمایاں کریں جہاں وہ آخری بٹ 1 ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1? ",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "ہمیں جو ملتا ہے وہ ہمارے چار برابری گروپوں میں سے پہلا ہے، جس کا مطلب ہے کہ آپ اس پہلے چیک کو پوچھنے سے تعبیر کر سکتے ہیں، ارے، اگر کوئی خرابی ہے، تو کیا اس غلطی کی پوزیشن میں آخری حصہ 1 ہے؟ اسی طرح، اگر آپ دوسرے سے آخری بٹ پر توجہ مرکوز کرتے ہیں، اور ان تمام پوزیشنوں کو نمایاں کرتے ہیں جہاں وہ 1 ہے، تو آپ کو ہماری اسکیم سے دوسرا برابری گروپ ملتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -144,7 +144,7 @@
   "end": 155.74
  },
  {
-  "input": "Similarly, if you focus on the second to last bit, and highlight all the positions where that's a 1, you get the second parity group from our scheme. ",
+  "input": "Similarly, if you focus on the second to last bit, and highlight all the positions where that's a 1, you get the second parity group from our scheme.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -152,7 +152,7 @@
   "end": 166.16
  },
  {
-  "input": "ly spelled words. Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. ",
+  "input": "In other words, that second check is asking, hey, me again, if there's an error, is the second to last bit of that position a 1?",
   "translatedText": "دوسرے لفظوں میں، وہ دوسرا چیک پوچھ رہا ہے، ارے، مجھے دوبارہ، اگر کوئی غلطی ہے، تو کیا اس پوزیشن کا دوسرا آخری حصہ 1 ہے؟ اور اسی طرح. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "And so on. ",
+  "input": "And so on.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -168,7 +168,7 @@
   "end": 176.9
  },
  {
-  "input": "The third parity check covers every position whose third to last bit is turned on, and the last one covers the last eight positions, those ones whose highest order bit is a 1. ",
+  "input": "The third parity check covers every position whose third to last bit is turned on, and the last one covers the last eight positions, those ones whose highest order bit is a 1.",
   "translatedText": "تیسرا برابری چیک ہر اس پوزیشن کا احاطہ کرتا ہے جس کا تیسرا سے آخری بٹ آن ہے، اور آخری ایک آخری آٹھ پوزیشنوں کا احاطہ کرتا ہے، وہ جن کا سب سے زیادہ آرڈر بٹ 1 ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -176,7 +176,7 @@
   "end": 188.74
  },
  {
-  "input": "everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary. ",
+  "input": "Everything we did earlier is the same as answering these four questions, which in turn is the same as spelling out a position in binary.",
   "translatedText": "ہم نے پہلے جو کچھ کیا وہ ان چار سوالوں کے جوابات کے برابر ہے، جو کہ بائنری میں پوزیشن کو ہجے کرنے کے مترادف ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -184,7 +184,7 @@
   "end": 197.74
  },
  {
-  "input": "It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where tha ",
+  "input": "I hope this makes two things clearer.",
   "translatedText": "مجھے امید ہے کہ اس سے دو چیزیں واضح ہو جائیں گی۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "t final bit is a 1. What we get is the first of our four parity groups, which means that you can interpret that first check as asking, hey, if there's an err ",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "پہلا یہ ہے کہ کس طرح منظم طریقے سے ان سائزوں کو بلاک کرنا ہے جو دو کی بڑی طاقتیں ہیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -200,7 +200,7 @@
   "end": 206.46
  },
  {
-  "input": "If it takes more bits to describe each position, like six bits to describe 64 spots, then each of those bits gives you one of the parity groups that we need to check. ",
+  "input": "If it takes more bits to describe each position, like six bits to describe 64 spots, then each of those bits gives you one of the parity groups that we need to check.",
   "translatedText": "اگر ہر پوزیشن کو بیان کرنے میں مزید بٹس لگتے ہیں، جیسے 64 مقامات کو بیان کرنے کے لیے چھ بٹس، تو ان بٹس میں سے ہر ایک آپ کو برابری والے گروپوں میں سے ایک دیتا ہے جسے ہمیں چیک کرنے کی ضرورت ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -208,7 +208,7 @@
   "end": 216.68
  },
  {
-  "input": "maybe at the end or something like that, but as you'll see, having them sit in positions which are powers of 2 allows for something that's really elegant by the end. ",
+  "input": "Those of you who watched the chessboard puzzle I did with Matt Parker might find all this exceedingly familiar.",
   "translatedText": "آپ میں سے وہ لوگ جنہوں نے میٹ پارکر کے ساتھ میں نے شطرنج کی تختی کی پہیلی دیکھی ہے شاید وہ یہ سب کچھ بہت زیادہ مانوس محسوس کریں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -216,7 +216,7 @@
   "end": 223.18
  },
  {
-  "input": "It's the same core logic, but solving a different problem, and applied to a 64-squared chessboard. ",
+  "input": "It's the same core logic, but solving a different problem, and applied to a 64-squared chessboard.",
   "translatedText": "یہ ایک ہی بنیادی منطق ہے، لیکن ایک مختلف مسئلہ کو حل کرنا، اور 64 مربع شطرنج پر لاگو ہوتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -224,7 +224,7 @@
   "end": 228.78
  },
  {
-  "input": "The second thing I hope this makes clear is why our parity bits are sitting in the positions that are powers of two, for example 1, 2, 4, and 8. ",
+  "input": "The second thing I hope this makes clear is why our parity bits are sitting in the positions that are powers of two, for example 1, 2, 4, and 8.",
   "translatedText": "دوسری چیز جو مجھے امید ہے کہ اس سے واضح ہوتا ہے کہ ہمارے برابری بٹس ان پوزیشنوں پر کیوں بیٹھے ہیں جو دو کی طاقتیں ہیں، مثال کے طور پر 1، 2، 4، اور 8۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -232,7 +232,7 @@
   "end": 237.32
  },
  {
-  "input": "at goes on at position 0, but don't worry about that for now. The third parity check covers every position whose third to last bit is turned ",
+  "input": "These are the positions whose binary representation has just a single bit turned on.",
   "translatedText": "یہ وہ پوزیشنیں ہیں جن کی بائنری نمائندگی صرف ایک بٹ آن ہوئی ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups. ",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "اس کا مطلب یہ ہے کہ ان میں سے ہر ایک برابری بٹس ایک کے اندر بیٹھتا ہے اور چار برابری گروپوں میں سے صرف ایک۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -248,7 +248,7 @@
   "end": 249.46
  },
  {
-  "input": "You can also see this in larger examples, where no matter how big you get, each parity bit conveniently touches only one of the groups. ",
+  "input": "You can also see this in larger examples, where no matter how big you get, each parity bit conveniently touches only one of the groups.",
   "translatedText": "آپ اسے بڑی مثالوں میں بھی دیکھ سکتے ہیں، جہاں اس سے کوئی فرق نہیں پڑتا ہے کہ آپ کتنے ہی بڑے کیوں نہ ہوں، ہر برابری بٹ آسانی سے گروپوں میں سے صرف ایک کو چھوتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -256,7 +256,7 @@
   "end": 259.34
  },
  {
-  "input": "Once you understand that these parity checks that we've focused so much of our time on are nothing more than a clever way to spell out the position of an error in binary, then we can draw a connection with a different way to think about hamming codes, one that is arguably a lot simpler and more elegant, and which can basically be written down with a single line of code. ",
+  "input": "Once you understand that these parity checks that we've focused so much of our time on are nothing more than a clever way to spell out the position of an error in binary, then we can draw a connection with a different way to think about hamming codes, one that is arguably a lot simpler and more elegant, and which can basically be written down with a single line of code.",
   "translatedText": "ایک بار جب آپ یہ سمجھ لیں کہ یہ برابری کی جانچ پڑتال جن پر ہم نے اپنا بہت زیادہ وقت صرف کیا ہے وہ بائنری میں خرابی کی پوزیشن کو واضح کرنے کے ایک ہوشیار طریقے سے زیادہ کچھ نہیں ہیں، پھر ہم ہیمنگ کے بارے میں سوچنے کے ایک مختلف طریقے سے تعلق کھینچ سکتے ہیں۔کوڈز، جو کہ بہت آسان اور زیادہ خوبصورت ہے، اور جسے بنیادی طور پر کوڈ کی ایک لائن کے ساتھ لکھا جا سکتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -264,7 +264,7 @@
   "end": 283.24
  },
  {
-  "input": "It's based on the XOR function. ",
+  "input": "It's based on the XOR function.",
   "translatedText": "یہ XOR فنکشن پر مبنی ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -272,7 +272,7 @@
   "end": 285.5
  },
  {
-  "input": "f 1s in the message is an even number. So for example right now, that total number of 1s is If it takes more bits to describe each p ",
+  "input": "XOR, for those of you who don't know, stands for exclusive or.",
   "translatedText": "XOR، آپ میں سے ان لوگوں کے لیے جو نہیں جانتے، خصوصی یا کے لیے کھڑا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "osition, like six bits to describe 64 spots, then each of those bits gives you one of the parity groups that we need to check. that special bit to be a 1, making the count even. But if the block had already started off with a ",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "جب آپ دو بٹس کا XOR لیتے ہیں، تو یہ 1 واپس کرنے جا رہا ہے اگر ان میں سے کوئی ایک بٹس آن ہو، لیکن نہیں اگر دونوں آن یا آف ہوں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "Phrased differently, it's the parity of these two bits. ",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "مختلف طریقے سے جملے، یہ ان دو بٹس کی برابری ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -296,7 +296,7 @@
   "end": 302.98
  },
  {
-  "input": "it would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core ",
+  "input": "As a math person, I prefer to think about it as addition mod 2.",
   "translatedText": "ایک ریاضی کے فرد کے طور پر، میں اس کے بارے میں اضافی موڈ 2 کے طور پر سوچنا پسند کرتا ہوں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -304,7 +304,7 @@
   "end": 306.76
  },
  {
-  "input": "logic, but solving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity bits are sitti ",
+  "input": "We also commonly talk about the XOR of two different bit strings, which basically does this component by component.",
   "translatedText": "ہم عام طور پر دو مختلف بٹ سٹرنگز کے XOR کے بارے میں بھی بات کرتے ہیں، جو بنیادی طور پر اس جزو کو جزو کے لحاظ سے کرتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "It's like addition, but where you never carry. ",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "یہ اضافے کی طرح ہے، لیکن جہاں آپ کبھی نہیں لے جاتے ہیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -320,7 +320,7 @@
   "end": 315.72
  },
  {
-  "input": "Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. ",
+  "input": "Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2.",
   "translatedText": "ایک بار پھر، زیادہ ریاضی کی طرف مائل اس کے بارے میں سوچنا پسند کریں گے کہ دو ویکٹر کو شامل کرنا اور موڈ 2 کو کم کرنا۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -328,7 +328,7 @@
   "end": 322.48
  },
  {
-  "input": "of two, for example 1, 2, 4, and 8. These are the positions whose binary representation has just a single bit turned on. d say the parity is 0 or 1, which is typically more helpful once you start doing math with the idea. And this special bit that the sender uses to con ",
+  "input": "If you open up some Python right now and apply the caret operation between two integers, this is what it's doing but to the bit representations of those numbers under the hood.",
   "translatedText": "اگر آپ ابھی کچھ Python کھولتے ہیں اور کیریٹ آپریشن کو دو عدد کے درمیان لاگو کرتے ہیں، تو یہ وہی کام کر رہا ہے لیکن ہڈ کے نیچے ان نمبروں کی تھوڑا سا نمائندگی کرنے کے لئے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "trol the parity is called the parity bit. And actually, we should be clear, if the receiver sees an odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure tha ",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "آپ کے اور میرے لیے اہم نکتہ یہ ہے کہ بہت سے مختلف بٹ سٹرنگز کا XOR لینا مؤثر طریقے سے الگ الگ گروپس کی پیروڈیز کی گنتی کرنے کا ایک طریقہ ہے، جیسا کہ کالموں کے ساتھ، سبھی ایک ساتھ جھپٹ پڑے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation. ",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "یہ ہمیں ہمارے ہیمنگ کوڈ الگورتھم سے متعدد برابری کی جانچ پڑتال کے بارے میں سوچنے کا ایک آسان طریقہ فراہم کرتا ہے کیونکہ سبھی کو ایک ہی آپریشن میں ایک ساتھ پیک کیا جاتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -352,7 +352,7 @@
   "end": 358.78
  },
  {
-  "input": "Though at first glance it does look very different. ",
+  "input": "Though at first glance it does look very different.",
   "translatedText": "اگرچہ پہلی نظر میں یہ بہت مختلف نظر آتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -360,7 +360,7 @@
   "end": 362.18
  },
  {
-  "input": "Specifically write down the 16 positions in binary, like we had before, and now highlight the positions where the message bit is turned on to a 1, and then collect these positions into one big column and take the XOR. ",
+  "input": "Specifically write down the 16 positions in binary, like we had before, and now highlight the positions where the message bit is turned on to a 1, and then collect these positions into one big column and take the XOR.",
   "translatedText": "خاص طور پر بائنری میں 16 پوزیشنز کو لکھیں، جیسا کہ ہمارے پاس پہلے تھا، اور اب ان پوزیشنز کو ہائی لائٹ کریں جہاں میسج بٹ کو 1 پر آن کیا گیا ہے، اور پھر ان پوزیشنز کو ایک بڑے کالم میں اکٹھا کریں اور XOR لیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -368,7 +368,7 @@
   "end": 377.1
  },
  {
-  "input": "You can probably guess that the 4 bits sitting at the bottom as a result are the same as the 4 parity checks we've come to know and love, but take a moment to actually think about why exactly. ",
+  "input": "You can probably guess that the 4 bits sitting at the bottom as a result are the same as the 4 parity checks we've come to know and love, but take a moment to actually think about why exactly.",
   "translatedText": "آپ شاید اندازہ لگا سکتے ہیں کہ نتیجے کے طور پر نیچے بیٹھے 4 بٹس 4 برابری کی جانچ کے برابر ہیں جو ہم جانتے ہیں اور پسند کرتے ہیں، لیکن حقیقت میں اس کے بارے میں سوچنے کے لیے ایک لمحہ نکالیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -376,7 +376,7 @@
   "end": 389.2
  },
  {
-  "input": "This last column, for example, is counting all of the positions whose last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. ",
+  "input": "This last column, for example, is counting all of the positions whose last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group.",
   "translatedText": "مثال کے طور پر، یہ آخری کالم ان تمام پوزیشنوں کو گن رہا ہے جن کا آخری بٹ ایک 1 ہے، لیکن ہم پہلے سے ہی صرف نمایاں کردہ پوزیشنوں تک محدود ہیں، اس لیے یہ مؤثر طریقے سے شمار کر رہا ہے کہ پہلے برابری گروپ سے کتنی نمایاں پوزیشنیں آئیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is ",
+  "input": "Does that make sense?",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "turned on, but not if both are turned on or if both are turned off. Phrased differently, it's the parity of these two bits. full message down to a single bit, what they give us is a powerful building block for more sophisticated schemes. ",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "کیا اسکا کوئ مطلب بنتا ہے؟ اسی طرح، اگلا کالم شمار کرتا ہے کہ دوسرے برابری گروپ میں کتنی پوزیشنیں ہیں، وہ پوزیشنیں جن کا دوسرا سے آخری بٹ 1 ہے، اور جن پر روشنی ڈالی گئی ہے، وغیرہ۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -400,7 +400,7 @@
   "end": 420.0
  },
  {
-  "input": "It's really just a small shift in perspective on the same thing we've been doing. ",
+  "input": "It's really just a small shift in perspective on the same thing we've been doing.",
   "translatedText": "یہ وہی چیز ہے جو ہم کر رہے ہیں کے نقطہ نظر میں واقعی صرف ایک چھوٹی سی تبدیلی ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -408,7 +408,7 @@
   "end": 423.96
  },
  {
-  "input": "e also commonly talk about the XOR of two different bit s ",
+  "input": "And so you know where it goes from here.",
   "translatedText": "اور اس طرح آپ جانتے ہیں کہ یہ یہاں سے کہاں جاتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -416,7 +416,7 @@
   "end": 429.6
  },
  {
-  "input": "The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000. ",
+  "input": "The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
   "translatedText": "بھیجنے والا کچھ خاص برابری بٹس کو ٹوگل کرنے کے لیے ذمہ دار ہے تاکہ یہ یقینی بنایا جا سکے کہ رقم 0000 بنتی ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error. ",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "اب ایک بار جب ہمارے پاس یہ اس طرح ہو جائے تو، یہ ہمیں یہ سوچنے کا ایک بہت اچھا طریقہ فراہم کرتا ہے کہ نچلے حصے میں یہ چار نتیجے والے بٹس براہ راست غلطی کی پوزیشن کو کیوں ظاہر کرتے ہیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "Let's say some bit in this block gets toggled from a 0 to a 1. ",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "آئیے کہتے ہیں کہ اس بلاک میں تھوڑا سا 0 سے 1 تک ٹوگل ہوجاتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. ",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "اس کا مطلب یہ ہے کہ اس بٹ کی پوزیشن اب کل XOR میں شامل ہونے جا رہی ہے، جو رقم کو 0 سے بدل کر اس نئی شامل ویلیو، غلطی کی پوزیشن میں تبدیل کر دیتی ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -448,7 +448,7 @@
   "end": 463.82
  },
  {
-  "input": "Slightly less obviously, the same is true if there's an error that changes a 1 to a 0. ",
+  "input": "Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
   "translatedText": "قدرے کم واضح طور پر، یہی بات درست ہے اگر کوئی ایسی غلطی ہو جو 1 کو 0 میں بدل دیتی ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -456,7 +456,7 @@
   "end": 469.36
  },
  {
-  "input": "ey point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop. This gives us a rather snazzy way ",
+  "input": "You see, if you add a bit string together twice, it's the same as not having it there at all, basically because in this world 1 plus 1 equals 0.",
   "translatedText": "آپ دیکھتے ہیں، اگر آپ دو بار ایک ساتھ تھوڑا سا سٹرنگ جوڑتے ہیں، تو یہ بالکل ایسا ہی ہے جیسا کہ اس کا وہاں بالکل نہ ہونا، بنیادی طور پر کیونکہ اس دنیا میں 1 جمع 1 برابر 0 ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -464,7 +464,7 @@
   "end": 477.94
  },
  {
-  "input": "to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation. ",
+  "input": "So adding a copy of this position to the total sum has the same effect as we're moving it.",
   "translatedText": "لہذا اس پوزیشن کی ایک کاپی کو کل رقم میں شامل کرنے کا وہی اثر ہوتا ہے جیسا کہ ہم اسے منتقل کر رہے ہیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -472,7 +472,7 @@
   "end": 484.3
  },
  {
-  "input": "Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the mes ",
+  "input": "And that effect, again, is that the total result at the bottom here spells out the position of the error.",
   "translatedText": "اور وہ اثر، ایک بار پھر، یہ ہے کہ یہاں نیچے کا کل نتیجہ غلطی کی پوزیشن کو ظاہر کرتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -480,7 +480,7 @@
   "end": 490.7
  },
  {
-  "input": "sage bit is turned on to a 1, and then collect these positions into one big column and take the XOR. You can probably guess that the four bits sitting at the bottom as a resu ",
+  "input": "To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all of the logic on the receiver's end.",
   "translatedText": "یہ بتانے کے لیے کہ یہ کتنا خوبصورت ہے، میں دکھاتا ہوں کہ ازگر کے کوڈ کی ایک لائن جس کا میں نے پہلے حوالہ دیا تھا، جو وصول کنندہ کے سرے پر موجود تقریباً تمام منطق کو پکڑ لے گی۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "lt are the same as the four parity checks we've come to know and love, but take a moment to actually think about why exactly. This last column, for example, is counting all of the positions whose last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. ",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "ہم ڈیٹا بلاک کی نقل کرنے کے لیے 16 1s اور 0s کی بے ترتیب صف بنا کر شروع کریں گے، اور میں اسے نام کے بٹس دوں گا، لیکن یقیناً عملی طور پر یہ وہ چیز ہوگی جو ہم بھیجنے والے سے وصول کر رہے ہیں، اور اس کے بجائے بے ترتیب ہونے کی وجہ سے یہ 5 برابری بٹس کے ساتھ 11 ڈیٹا بٹس لے کر جائے گا۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -496,7 +496,7 @@
   "end": 517.4
  },
  {
-  "input": "If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15. ",
+  "input": "If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
   "translatedText": "اگر میں فنکشن کو enumerateBits کہتا ہوں، تو یہ جو کرتا ہے ان میں سے ہر ایک بٹس کو متعلقہ انڈیکس کے ساتھ جوڑتا ہے، اس صورت میں 0 سے 15 تک چل رہا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ht half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit, so these 8 bits already have an even pari Likewise, the next column counts how many positions are in the second parity group, the positions whose second to las ",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "لہذا اگر ہم پھر ایک فہرست بناتے ہیں جو ان تمام جوڑوں پر نظر آتی ہے، جوڑے جو i کی طرح نظر آتے ہیں، اور پھر ہم صرف i ویلیو کو نکالتے ہیں، صرف انڈیکس، ٹھیک ہے یہ اتنا دلچسپ نہیں ہے، ہم صرف ان انڈیکس کو 0 سے 15 تک واپس کر دیتے ہیں۔. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on. ",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "لیکن اگر ہم اس شرط کو شامل کریں کہ یہ صرف اگر بٹ ہے، یعنی اگر وہ بٹ 1 ہے نہ کہ 0، تو یہ صرف ان پوزیشنوں کو نکالتا ہے جہاں متعلقہ بٹ آن ہوتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -520,7 +520,7 @@
   "end": 552.66
  },
  {
-  "input": "ve on the same thing we've been doing. but for right now we're going to assume ",
+  "input": "In this case it looks like those positions are 0, 4, 6, 9, etc.",
   "translatedText": "اس معاملے میں ایسا لگتا ہے کہ وہ پوزیشنیں 0، 4، 6، 9، وغیرہ ہیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -528,7 +528,7 @@
   "end": 557.96
  },
  {
-  "input": "What we want is to collect together all of those positions, the positions of the bits that are turned on, and then XOR them together. ",
+  "input": "What we want is to collect together all of those positions, the positions of the bits that are turned on, and then XOR them together.",
   "translatedText": "ہم جو چاہتے ہیں وہ ان تمام پوزیشنوں کو اکٹھا کرنا ہے، بٹس کی پوزیشنز جو آن ہیں، اور پھر ان کو ایک ساتھ XOR کریں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -536,7 +536,7 @@
   "end": 567.24
  },
  {
-  "input": "The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 000 ",
+  "input": "To do this in Python, let me first import a couple helpful functions.",
   "translatedText": "Python میں ایسا کرنے کے لیے، مجھے پہلے ایک دو مددگار فنکشنز درآمد کرنے دیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -544,7 +544,7 @@
   "end": 573.22
  },
  {
-  "input": "That way we can call reduce() on this list, and use the XOR function to reduce it. ",
+  "input": "That way we can call reduce() on this list, and use the XOR function to reduce it.",
   "translatedText": "اس طرح ہم اس فہرست میں reduce() کو کال کر سکتے ہیں، اور اسے کم کرنے کے لیے XOR فنکشن کا استعمال کر سکتے ہیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -552,7 +552,7 @@
   "end": 578.7
  },
  {
-  "input": "es us a really nice way to think about why these four resulting bits at the bottom directly spell out the pos ",
+  "input": "This basically eats its way through the list, taking XORs along the way.",
   "translatedText": "یہ بنیادی طور پر فہرست کے ذریعے اپنا راستہ کھاتا ہے، راستے میں XORs کو لے جاتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -560,7 +560,7 @@
   "end": 582.68
  },
  {
-  "input": "ition of an error. Let's say you detect an error among the odd columns, and among the right half. It necessarily means the error is somewhere in th ",
+  "input": "If you prefer, you can explicitly write out that XOR function without having to import it from anywhere.",
   "translatedText": "اگر آپ چاہیں تو، آپ واضح طور پر اس XOR فنکشن کو کہیں سے درآمد کیے بغیر لکھ سکتے ہیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -568,7 +568,7 @@
   "end": 589.44
  },
  {
-  "input": "So at the moment it looks like if we do this on our random block of 16 bits, it returns 9, which has the binary representation 1001. ",
+  "input": "So at the moment it looks like if we do this on our random block of 16 bits, it returns 9, which has the binary representation 1001.",
   "translatedText": "تو اس وقت ایسا لگتا ہے کہ اگر ہم یہ اپنے 16 بٹس کے بے ترتیب بلاک پر کرتے ہیں، تو یہ 9 لوٹاتا ہے، جس کی بائنری نمائندگی 1001 ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0. ",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "ہم یہ یہاں نہیں کریں گے، لیکن آپ ایک فنکشن لکھ سکتے ہیں جہاں بھیجنے والا اس بائنری نمائندگی کا استعمال کرتے ہوئے ضرورت کے مطابق چار برابری بٹس کو سیٹ کرتا ہے، بالآخر اس بلاک کو ایسی حالت میں لے جاتا ہے جہاں بٹس کی مکمل فہرست پر کوڈ کی اس لائن کو چلانے سے واپسی ہوتی ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -584,7 +584,7 @@
   "end": 615.46
  },
  {
-  "input": "This would be considered a well-prepared block. ",
+  "input": "This would be considered a well-prepared block.",
   "translatedText": "ایک 0 یہ ایک اچھی طرح سے تیار شدہ بلاک سمجھا جائے گا۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. ",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "اچھی بات یہ ہے کہ اگر ہم اس فہرست میں سے کسی ایک بٹ کو ٹوگل کرتے ہیں، شور سے بے ترتیب غلطی کی نقل کرتے ہیں، پھر اگر آپ کوڈ کی اسی لائن کو چلاتے ہیں، تو یہ اس غلطی کو پرنٹ کرتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -600,7 +600,7 @@
   "end": 630.22
  },
  {
-  "input": "an error that changes a 1 to a 0. You see, if you add a bit string together twice, it's the same as ",
+  "input": "Isn't that neat?",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any. ",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "کیا یہ صاف نہیں ہے؟ آپ اس بلاک کو نیلے رنگ سے حاصل کر سکتے ہیں، اس پر اس سنگل لائن کو چلائیں، اور یہ خود بخود کسی غلطی کی پوزیشن کو ختم کر دے گا، یا اگر کوئی نہیں ہے تو 0۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -616,7 +616,7 @@
   "end": 641.06
  },
  {
-  "input": "And that effect, again, is that the total result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me sh ",
+  "input": "And there's nothing special about the size 16 here.",
   "translatedText": "اور یہاں سائز 16 کے بارے میں کچھ خاص نہیں ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -624,7 +624,7 @@
   "end": 645.2
  },
  {
-  "input": "The same line of code would work if you had a list of, say, 256 bits. ",
+  "input": "The same line of code would work if you had a list of, say, 256 bits.",
   "translatedText": "کوڈ کی ایک ہی لائن کام کرے گی اگر آپ کے پاس 256 بٹس کی فہرست ہو۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -632,7 +632,7 @@
   "end": 649.86
  },
  {
-  "input": "ferenced before, which will capture almost all of the logic on the receiver's end. We'll start by creating a random array of 16 ones and zeros to simulate the data block, and I'll go ahead and give it the name bits, but of course in practice this would be something that we're receiving f ",
+  "input": "Needless to say, there is more code to write here, like doing the meta parity check to detect 2-bit errors, but the idea is that almost all of the core logic from our scheme comes down to a single XOR reduction.",
   "translatedText": "یہ کہنے کی ضرورت نہیں کہ یہاں لکھنے کے لیے مزید کوڈ موجود ہیں، جیسے کہ 2 بٹ کی غلطیوں کا پتہ لگانے کے لیے میٹا پیریٹی چیک کرنا، لیکن خیال یہ ہے کہ ہماری اسکیم سے تقریباً تمام بنیادی منطق ایک XOR میں کمی پر آتی ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. ",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "اب، بائنری اور XORs اور عام طور پر سافٹ ویئر کے ساتھ آپ کے آرام پر منحصر ہے، آپ کو یا تو یہ نقطہ نظر تھوڑا سا الجھا ہوا، یا اتنا زیادہ خوبصورت اور سادہ لگ سکتا ہے کہ آپ سوچ رہے ہوں گے کہ ہم نے اس کے ساتھ شروع ہی کیوں نہیں کیا۔-جاؤ. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level. ",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "ڈھیلے الفاظ میں، ہارڈ ویئر میں ہیمنگ کوڈز کو براہ راست لاگو کرتے وقت ایک سے زیادہ برابری کی جانچ کے نقطہ نظر کے بارے میں سوچنا آسان ہے، اور XOR نقطہ نظر کے بارے میں سوچنا آسان ہے کہ اسے سافٹ ویئر میں کرتے وقت، ایک اعلی سطح سے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -656,7 +656,7 @@
   "end": 690.5
  },
  {
-  "input": "l out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on. In this case it looks like those positions are 0, 4, 6, 9, etc. Remember, what ",
+  "input": "The first one is easiest to actually do by hand, and I think it does a better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the log of the size of the block, or in other words, it grows one bit at a time as the block size doubles.",
   "translatedText": "پہلا اصل میں ہاتھ سے کرنا سب سے آسان ہے، اور مجھے لگتا ہے کہ یہ ان سب کے بنیادی وجدان کو پیدا کرنے میں ایک بہتر کام کرتا ہے، جو کہ ایک غلطی کا پتہ لگانے کے لیے درکار معلومات کا تعلق بلاک کے سائز کے لاگ سے ہے۔، یا دوسرے الفاظ میں، یہ ایک وقت میں تھوڑا سا بڑھتا ہے کیونکہ بلاک کا سائز دوگنا ہوتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "we want is to collect together all of those positions, the positions of the bits that are turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. ",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "یہاں متعلقہ حقیقت یہ ہے کہ وہ معلومات براہ راست اس بات سے مطابقت رکھتی ہے کہ ہمیں کتنی بے کاری کی ضرورت ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -672,7 +672,7 @@
   "end": 716.06
  },
  {
-  "input": "That's really what runs against most people's knee-jerk reaction when they first think about making a message resilient to errors, where usually copying the whole message is the first instinct that comes to mind. ",
+  "input": "That's really what runs against most people's knee-jerk reaction when they first think about making a message resilient to errors, where usually copying the whole message is the first instinct that comes to mind.",
   "translatedText": "یہی وہ چیز ہے جو زیادہ تر لوگوں کے گھٹنے ٹیکنے والے ردعمل کے خلاف چلتی ہے جب وہ پہلی بار کسی پیغام کو غلطیوں کے لیے لچکدار بنانے کے بارے میں سوچتے ہیں، جہاں عام طور پر پورے پیغام کو کاپی کرنا ذہن میں آنے والی پہلی جبلت ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix. ",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "اور پھر، ویسے، یہ پورا دوسرا طریقہ ہے کہ آپ کبھی کبھی ہیمنگ کوڈز کو پیش کرتے ہوئے دیکھتے ہیں، جہاں آپ پیغام کو ایک بڑے میٹرکس سے ضرب دیتے ہیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -688,7 +688,7 @@
   "end": 734.0
  },
  {
-  "input": "It's kind of nice because it relates it to the broader family of linear codes, but I think that gives almost no intuition for where it comes from or how it scales. ",
+  "input": "It's kind of nice because it relates it to the broader family of linear codes, but I think that gives almost no intuition for where it comes from or how it scales.",
   "translatedText": "یہ ایک طرح کا اچھا ہے کیونکہ اس کا تعلق لکیری کوڈز کے وسیع تر خاندان سے ہے، لیکن مجھے لگتا ہے کہ یہ کہاں سے آتا ہے یا اس کی پیمائش کیسے ہوتی ہے اس کے بارے میں تقریباً کوئی وجدان نہیں دیتا۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. ",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "اور اسکیلنگ کی بات کرتے ہوئے، آپ محسوس کر سکتے ہیں کہ اس اسکیم کی کارکردگی صرف اسی وقت بہتر ہوتی ہے جب ہم بلاک سائز میں اضافہ کرتے ہیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "looks like if we do this on our random block of 16 bits, it returns 9, which has the binary representation 1001. We won't do it here, but you could write a function wh ",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "مثال کے طور پر، ہم نے دیکھا کہ 256 بٹس کے ساتھ، آپ اس جگہ کا صرف 3% فالتو پن کے لیے استعمال کر رہے ہیں، اور یہ وہاں سے بہتر ہوتا جا رہا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ere the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a state where running th ",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "جیسے جیسے برابری بٹس کی تعداد ایک ایک کرکے بڑھتی ہے، بلاک کا سائز دوگنا ہوتا رہتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits. ",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "اور اگر آپ اسے انتہائی حد تک لے جاتے ہیں، تو آپ کے پاس ایک ملین بٹس کا بلاک ہو سکتا ہے، جہاں آپ لفظی طور پر اپنے برابری کی جانچ کے ساتھ 20 سوالات کھیل رہے ہوں گے، اور یہ صرف 21 برابری بٹس کا استعمال کرتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -728,7 +728,7 @@
   "end": 780.02
  },
  {
-  "input": "And if you step back to think about looking at a million bits and locating a single error, that genuinely feels crazy. ",
+  "input": "And if you step back to think about looking at a million bits and locating a single error, that genuinely feels crazy.",
   "translatedText": "اور اگر آپ ایک ملین بٹس کو دیکھنے اور ایک غلطی کا پتہ لگانے کے بارے میں سوچنے کے لئے پیچھے ہٹتے ہیں، تو یہ واقعی پاگل محسوس ہوتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that. ",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "مسئلہ، یقیناً، یہ ہے کہ بڑے بلاک کے ساتھ، ایک یا دو سے زیادہ خرابیاں دیکھنے کا امکان بڑھ جاتا ہے، اور ہیمنگ کوڈز اس سے آگے کچھ نہیں سنبھالتے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -744,7 +744,7 @@
   "end": 797.66
  },
  {
-  "input": "So in practice, what you'd want is to find the right size so that the probability of too many bit flips isn't too high. ",
+  "input": "So in practice, what you'd want is to find the right size so that the probability of too many bit flips isn't too high.",
   "translatedText": "لہذا عملی طور پر، آپ صحیح سائز تلاش کرنا چاہتے ہیں تاکہ بہت زیادہ بٹ پلٹنے کا امکان بہت زیادہ نہ ہو۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -752,7 +752,7 @@
   "end": 804.3
  },
  {
-  "input": "imulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the positio ",
+  "input": "Also, in practice, errors tend to come in little bursts, which would totally ruin a single block, so one common tactic to help spread out a burst of errors across many different blocks is to interlace those blocks, like this, before they're sent out or stored.",
   "translatedText": "اس کے علاوہ، عملی طور پر، غلطیاں تھوڑی دیر میں آتی ہیں، جو ایک ہی بلاک کو مکمل طور پر برباد کر دیتی ہیں، لہذا بہت سے مختلف بلاکس میں غلطیوں کو پھیلانے میں مدد کرنے کے لیے ایک عام حربہ یہ ہے کہ ان بلاکس کو آپس میں جوڑنا، اس طرح، ان کے ہونے سے پہلے۔بھیج دیا گیا یا ذخیرہ کیا گیا۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -760,7 +760,7 @@
   "end": 820.98
  },
  {
-  "input": "Then again, a lot of this is rendered completely moot by more modern codes, like the much more commonly used Reed-Solomon algorithm, which handles burst errors particularly well, and it can be tuned to be resilient to a larger number of errors per block. ",
+  "input": "Then again, a lot of this is rendered completely moot by more modern codes, like the much more commonly used Reed-Solomon algorithm, which handles burst errors particularly well, and it can be tuned to be resilient to a larger number of errors per block.",
   "translatedText": "پھر ایک بار پھر، اس میں سے بہت کچھ کو زیادہ جدید کوڈز کے ذریعے مکمل طور پر پیش کیا جاتا ہے، جیسے کہ بہت زیادہ عام طور پر استعمال ہونے والا Reed-Solomon الگورتھم، جو برسٹ کی غلطیوں کو خاص طور پر اچھی طرح سے ہینڈل کرتا ہے، اور اسے فی بلاک میں بڑی تعداد میں غلطیوں کے لیے لچکدار ہونے کے لیے بنایا جا سکتا ہے۔. ",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "But that's a topic for another time. ",
+  "input": "But that's a topic for another time.",
   "translatedText": "لیکن یہ کسی اور وقت کا موضوع ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was. ",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "اپنی کتاب دی آرٹ آف ڈوئنگ سائنس اینڈ انجینئرنگ میں، ہیمنگ حیرت انگیز طور پر اس بات کے بارے میں واضح ہے کہ اس کوڈ کے بارے میں ان کی دریافت کتنی گھمبیر تھی۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -784,7 +784,7 @@
   "end": 849.94
  },
  {
-  "input": "He first tried all sorts of different schemes involving organizing the bits into parts of a higher dimensional lattice and strange things like this. ",
+  "input": "He first tried all sorts of different schemes involving organizing the bits into parts of a higher dimensional lattice and strange things like this.",
   "translatedText": "اس نے سب سے پہلے ہر طرح کی مختلف اسکیموں کو آزمایا جس میں بٹس کو اعلی جہتی جالی کے حصوں میں ترتیب دینا اور اس طرح کی عجیب و غریب چیزیں شامل تھیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -792,7 +792,7 @@
   "end": 857.78
  },
  {
-  "input": "The idea that it might be possible to get parity checks to conspire in a way that spells out the position of an error only came to Hamming when he stepped back after a bunch of other analysis and asked, okay, what is the most efficient I could conceivably be about this? ",
+  "input": "The idea that it might be possible to get parity checks to conspire in a way that spells out the position of an error only came to Hamming when he stepped back after a bunch of other analysis and asked, okay, what is the most efficient I could conceivably be about this?",
   "translatedText": "یہ خیال کہ اس طرح سے سازش کرنے کے لیے برابری کی جانچ پڑتال ممکن ہو سکتی ہے جس سے غلطی کی پوزیشن کو واضح کیا جا سکتا ہے، ہیمنگ کو صرف اس وقت آیا جب اس نے دوسرے تجزیوں کے ایک گروپ کے بعد پیچھے ہٹ کر پوچھا، ٹھیک ہے، میں سب سے زیادہ موثر کون سا ہے؟ شاید اس کے بارے میں ہو؟ وہ اس بارے میں بھی واضح تھا کہ یہ کتنا اہم تھا کہ برابری کی جانچ پڑتال پہلے سے ہی اس کے ذہن میں تھی، جو آج کی نسبت 1940 کی دہائی میں بہت کم عام ہوتی۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -800,7 +800,7 @@
   "end": 871.52
  },
  {
-  "input": "He was also candid about how important it was that parity checks were already on his mind, which would have been way less common back in the 1940s than it is today. ",
+  "input": "He was also candid about how important it was that parity checks were already on his mind, which would have been way less common back in the 1940s than it is today.",
   "translatedText": "",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "is perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it ",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "اس پوری کتاب میں نصف درجن کے قریب بار ہے کہ وہ لوئس پاسچر کے اقتباس کا حوالہ دیتے ہیں، قسمت ایک تیار دماغ کی حمایت کرتی ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -816,7 +816,7 @@
   "end": 888.22
  },
  {
-  "input": "Clever ideas often look deceptively simple in hindsight, which makes them easy to underappreciate. ",
+  "input": "Clever ideas often look deceptively simple in hindsight, which makes them easy to underappreciate.",
   "translatedText": "ہوشیار خیالات اکثر پیچھے کی نظر میں دھوکے سے سادہ نظر آتے ہیں، جس کی وجہ سے ان کی قدر کرنا آسان ہو جاتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -824,7 +824,7 @@
   "end": 894.3
  },
  {
-  "input": "Right now my honest hope is that Hamming codes, or at least the possibility of such codes, feels almost obvious to you. ",
+  "input": "Right now my honest hope is that Hamming codes, or at least the possibility of such codes, feels almost obvious to you.",
   "translatedText": "ابھی میری ایماندارانہ امید یہ ہے کہ ہیمنگ کوڈز، یا کم از کم اس طرح کے کوڈز کا امکان، آپ کے لیے تقریباً واضح محسوس ہوتا ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't. ",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "لیکن آپ کو یہ سوچ کر اپنے آپ کو بیوقوف نہیں بنانا چاہئے کہ وہ حقیقت میں واضح ہیں، کیونکہ وہ یقینی طور پر نہیں ہیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -840,7 +840,7 @@
   "end": 906.82
  },
  {
-  "input": ", with four yes or no questions, we have 16 possible outcomes for our parity checks, and at first that feels perfect for pinpointing 1 out of 16 positions in the block, but you also need to communicate a 17th outcome, the no error condition. The first one is easiest to actually do by hand, and I think it does a better job instilling the core intuition underlying all of this, ",
+  "input": "Part of the reason that clever ideas look deceptively easy is that we only ever see the final result, cleaning up what was messy, never mentioning all of the wrong turns, underselling just how vast the space of explorable possibilities is at the start of a problem solving process, all of that.",
   "translatedText": "ہوشیار خیالات دھوکہ دہی سے آسان نظر آنے کی ایک وجہ یہ ہے کہ ہم صرف حتمی نتیجہ دیکھتے ہیں، جو گندا تھا اسے صاف کرتے ہیں، تمام غلط موڑ کا کبھی ذکر نہیں کرتے، اس بات کو کم کرتے ہیں کہ کسی مسئلے کے آغاز میں قابل دریافت امکانات کی جگہ کتنی وسیع ہے۔حل کرنے کا عمل، یہ سب۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -848,7 +848,7 @@
   "end": 922.86
  },
  {
-  "input": "which is that the information required to locate a single error is relat ",
+  "input": "But this is true in general.",
   "translatedText": "لیکن یہ عام طور پر سچ ہے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -856,7 +856,7 @@
   "end": 924.9
  },
  {
-  "input": "ed to the log of the size of the block, or in other words, it grows one bit at a time as the block size doubles. The relevant fact here i ",
+  "input": "I think for some special inventions, there's a second, deeper reason that we underappreciate them.",
   "translatedText": "میرے خیال میں کچھ خاص ایجادات کے لیے، ایک دوسری، گہری وجہ ہے کہ ہم ان کی قدر نہیں کرتے۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -864,7 +864,7 @@
   "end": 930.04
  },
  {
-  "input": "Thinking of information in terms of bits had only really coalesced into a full theory by 1948, with Claude Shannon's seminal paper on information theory. ",
+  "input": "Thinking of information in terms of bits had only really coalesced into a full theory by 1948, with Claude Shannon's seminal paper on information theory.",
   "translatedText": "بٹس کے لحاظ سے معلومات کے بارے میں سوچنا صرف 1948 تک ایک مکمل تھیوری میں یکجا ہو گیا تھا، جس میں انفارمیشن تھیوری پر کلاڈ شینن کا سیمینل پیپر تھا۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -872,7 +872,7 @@
   "end": 938.64
  },
  {
-  "input": "block is even, just like a normal parity check. Now, if there's a single bit error, then ",
+  "input": "This was essentially concurrent with when Hamming developed his algorithm.",
   "translatedText": "یہ بنیادی طور پر اس کے ساتھ ہم آہنگ تھا جب ہیمنگ نے اپنا الگورتھم تیار کیا۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "the parity of the full block toggles to be odd, but we would catch that anyway thanks to the four error-correcting checks. However, if there's two errors, then the overall parity is going to toggle back to be And then, by the way, there is this whole other way that you s ",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "یہ وہی بنیادی کاغذ تھا جس نے ظاہر کیا، ایک خاص معنوں میں، غلطی کی مؤثر اصلاح ہمیشہ ممکن ہے، چاہے بٹ پلٹنے کا امکان کتنا ہی زیادہ ہو، کم از کم تھیوری میں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -888,7 +888,7 @@
   "end": 952.9
  },
  {
-  "input": "Shannon and Hamming, by the way, shared an office in Bell Labs, despite working on very different things, which hardly seems coincidental here. ",
+  "input": "Shannon and Hamming, by the way, shared an office in Bell Labs, despite working on very different things, which hardly seems coincidental here.",
   "translatedText": "شینن اور ہیمنگ، ویسے، بہت مختلف چیزوں پر کام کرنے کے باوجود، بیل لیبز میں ایک دفتر کا اشتراک کرتے ہیں، جو یہاں شاید ہی اتفاقیہ لگیں۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "multiply the message by one big matrix. It's kind of nice because it relates it to the broader family of linear codes, but I think that gives almost no intuition for where it comes from or how it scales. ",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "کئی دہائیوں سے تیزی سے آگے بڑھیں، اور ان دنوں، ہم میں سے بہت سے لوگ بٹس اور معلومات کے بارے میں سوچنے میں اتنے ڈوبے ہوئے ہیں کہ یہ نظر انداز کرنا آسان ہے کہ سوچنے کا یہ طریقہ کتنا الگ تھا۔",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -904,7 +904,7 @@
   "end": 972.34
  },
  {
-  "input": "Ironically, the ideas that most profoundly shape the ways that a future generation thinks will end up looking to that future generation simpler than they really are. ",
+  "input": "Ironically, the ideas that most profoundly shape the ways that a future generation thinks will end up looking to that future generation simpler than they really are.",
   "translatedText": "ستم ظریفی یہ ہے کہ وہ خیالات جو سب سے زیادہ گہرائی سے ان طریقوں کو تشکیل دیتے ہیں جن کے بارے میں ایک آنے والی نسل سوچتی ہے کہ وہ اس آنے والی نسل کو حقیقت سے کہیں زیادہ آسان نظر آئیں گے۔",
   "model": "google_nmt",
   "n_reviews": 0,
diff --git a/2020/hamming-codes-2/vietnamese/sentence_translations.json b/2020/hamming-codes-2/vietnamese/sentence_translations.json
index 6dcb1772d..6919145a8 100644
--- a/2020/hamming-codes-2/vietnamese/sentence_translations.json
+++ b/2020/hamming-codes-2/vietnamese/sentence_translations.json
@@ -8,7 +8,7 @@
   "end": 2.56
  },
  {
-  "input": "h a CD or a DVD and still have it play back whatever it's storing? The scratch really does affect the 1s and 0s on the disk, so it reads off different data from what was We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this b",
+  "input": "We were talking about Hamming codes, a way to create a block of data where most of the bits carry a meaningful message, while a few others act as a kind of redundancy, in such a way that if any bit gets flipped, either a message bit or a redundancy bit, anything in this block, a receiver is going to be able to identify that there was an error, and how to fix it.",
   "translatedText": "Chúng ta đang nói về mã Hamming, một cách để tạo ra một khối dữ liệu trong đó hầu hết các bit mang một thông điệp có ý nghĩa, trong khi một số bit khác hoạt động như một loại dự phòng, theo cách mà nếu bất kỳ bit nào bị đảo lộn, thì đó sẽ là một thông báo. bit hoặc bit dự phòng, bất kỳ thứ gì trong khối này, bộ thu sẽ có thể xác định rằng đã xảy ra lỗi và cách khắc phục.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -16,7 +16,7 @@
   "end": 21.24
  },
  {
-  "input": "lock, a receiver is going to be able to identify that there was an error, and how to fix it. The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
+  "input": "The basic idea presented there was how to use multiple parity checks to binary search your way down to the error.",
   "translatedText": "Ý tưởng cơ bản được trình bày ở đó là cách sử dụng nhiều biện pháp kiểm tra chẵn lẻ để tìm kiếm nhị phân theo cách của bạn để tìm ra lỗi.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -56,7 +56,7 @@
   "end": 64.08
  },
  {
-  "input": "For the better part of the last century, this field has been a really rich source of surprisingly deep math that gets incorporated into devices we use every day.",
+  "input": "For example, the number 7 in binary looks like 0111, essentially saying that it's 4 plus 2 plus 1.",
   "translatedText": "Ví dụ: số 7 trong hệ nhị phân trông giống như 0111, về cơ bản nó có nghĩa là 4 cộng 2 cộng 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -64,7 +64,7 @@
   "end": 71.26
  },
  {
-  "input": "The goal here is to give you a very thorough understanding of one of the earliest examples, known as a Hamming code. And notice where the position 7 sits. It does affect the first of our parity",
+  "input": "And notice where the position 7 sits, it does affect the first of our parity groups, and the second, and the third, but not the last.",
   "translatedText": "Và hãy để ý xem vị trí số 7 nằm ở đâu, nó ảnh hưởng đến nhóm đầu tiên trong số các nhóm ngang bằng của chúng ta, nhóm thứ hai và nhóm thứ ba, nhưng không ảnh hưởng đến nhóm cuối cùng.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -72,7 +72,7 @@
   "end": 81.74
  },
  {
-  "input": "groups, and the second, and the third, but not the last. So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
+  "input": "So reading the results of those four checks from bottom to top indeed does spell out the position of the error.",
   "translatedText": "Vì vậy, việc đọc kết quả của bốn lần kiểm tra đó từ dưới lên trên thực sự sẽ chỉ ra vị trí của lỗi.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -96,7 +96,7 @@
   "end": 109.88
  },
  {
-  "input": "ask feels at the start, and how utterly reasonable it seems once you learn about Hamming. The basic principle of error correction is that in a vast space of all possible messages, only some su",
+  "input": "As we put these binary labels back into their boxes, let me emphasize that they are distinct from the data that's actually being sent.",
   "translatedText": "Khi chúng ta đặt các nhãn nhị phân này trở lại hộp của chúng, hãy để tôi nhấn mạnh rằng chúng khác biệt với dữ liệu thực sự được gửi.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -104,7 +104,7 @@
   "end": 117.8
  },
  {
-  "input": "bset are going to be considered valid messages. As an analogy, think about correctly spelled words vs incorrectly spelled words.",
+  "input": "They're nothing more than a conceptual label to help you and me understand where the four parity groups came from.",
   "translatedText": "Chúng không gì khác hơn là một nhãn hiệu khái niệm để giúp bạn và tôi hiểu bốn nhóm ngang bằng đến từ đâu.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -112,7 +112,7 @@
   "end": 123.5
  },
  {
-  "input": "Whenever a valid message gets altered, the receiver is responsible for correcting what they see back to the nearest valid neighbor, as you might do with a typo. Coming up with a concrete algorithm to efficiently categorize messa",
+  "input": "The elegance of having everything we're looking at be described in binary is maybe undercut by the confusion of having everything we're looking at being described in binary.",
   "translatedText": "Sự sang trọng của việc mọi thứ chúng ta đang xem xét được mô tả ở dạng nhị phân có thể bị giảm bớt do sự nhầm lẫn khi mọi thứ chúng ta đang xem xét được mô tả ở dạng nhị phân.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -136,7 +136,7 @@
   "end": 143.22
  },
  {
-  "input": "be undercut by the confusion of having everything we're looking at being described in binary. It's worth it, though. Focus your attention just on that last bit of all of these labels. And then highlight the positions where that final bit is a 1. What we get is",
+  "input": "What we get is the first of our four parity groups, which means you can interpret that first check as asking, hey, if there's an error, is the final bit in the position of that error a 1?",
   "translatedText": "Những gì chúng tôi nhận được là nhóm đầu tiên trong số bốn nhóm chẵn lẻ, có nghĩa là bạn có thể hiểu lần kiểm tra đầu tiên đó là hỏi, này, nếu có lỗi, bit cuối cùng ở vị trí của lỗi đó có phải là 1 không?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -160,7 +160,7 @@
   "end": 174.5
  },
  {
-  "input": "hat error a 1? 4 special bits to come nicely packaged together, maybe at the end o",
+  "input": "And so on.",
   "translatedText": "Và như thế.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -192,7 +192,7 @@
   "end": 201.48
  },
  {
-  "input": "this scales f or larger blocks. Also technically it ends up being only 11 bits of data, you'll find there's a mild nuance for what goes on at position",
+  "input": "The first is how to systematically generalize to block sizes that are bigger powers of two.",
   "translatedText": "Đầu tiên là làm thế nào để khái quát hóa một cách có hệ thống các kích thước khối có lũy thừa lớn hơn bằng 2.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -240,7 +240,7 @@
   "end": 243.0
  },
  {
-  "input": "So that's the setup, but before we can dive in we need to talk about a related idea which was fresh on Hamming's mind in the time of his discovery, a I hope this makes two things clearer.",
+  "input": "What that means is each of those parity bits sits inside one and only one of the four parity groups.",
   "translatedText": "Điều đó có nghĩa là mỗi bit chẵn lẻ đó nằm bên trong một và chỉ một trong bốn nhóm chẵn lẻ.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -280,7 +280,7 @@
   "end": 290.22
  },
  {
-  "input": "But if the block had already started off with an even number of 1s, then this special bit would have been kept at a 0. This is pretty simple, deceptively simple, b It's the same core logic, but s",
+  "input": "When you take the XOR of two bits, it's going to return a 1 if either one of those bits is turned on, but not if both are turned on or off.",
   "translatedText": "Khi bạn lấy XOR của hai bit, nó sẽ trả về 1 nếu một trong hai bit đó được bật, nhưng không trả về nếu cả hai bit được bật hoặc tắt.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -288,7 +288,7 @@
   "end": 299.36
  },
  {
-  "input": "olving a different problem, and applied to a 64-squared chessboard. The second thing I hope this makes clear is why our parity",
+  "input": "Phrased differently, it's the parity of these two bits.",
   "translatedText": "Nói cách khác, đó là tính chẵn lẻ của hai bit này.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -312,7 +312,7 @@
   "end": 313.44
  },
  {
-  "input": "These are the positions whose binary representation has just a single bit turned on.",
+  "input": "It's like addition, but where you never carry.",
   "translatedText": "Nó giống như sự bổ sung, nhưng bạn không bao giờ mang theo.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -336,7 +336,7 @@
   "end": 332.94
  },
  {
-  "input": "odd parity, it doesn't necessarily mean there was just one error, there might have been 3 errors, or 5, or any other odd number, but they can know for sure that it wasn't 0. On the other hand, if there had been 2 errors, or any even number of errors, that final count of 1s would",
+  "input": "The key point for you and me is that taking the XOR of many different bit strings is effectively a way to compute the parodies of a bunch of separate groups, like so with the columns, all in one fell swoop.",
   "translatedText": "Điểm mấu chốt đối với bạn và tôi là việc lấy XOR của nhiều chuỗi bit khác nhau thực sự là một cách để tính toán các bản nhại của một loạt các nhóm riêng biệt, giống như với các cột, tất cả trong một cú trượt.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -344,7 +344,7 @@
   "end": 347.14
  },
  {
-  "input": "still be even, so the receiver can't have full confidence that an even count necessarily means the message is error-free. You might complain that a message which gets messed up by only 2 bit flips is pretty weak, and you would be absolutely right. Keep in mind",
+  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming code algorithm as all being packaged together into one single operation.",
   "translatedText": "Điều này mang lại cho chúng ta một cách khá thú vị để suy nghĩ về nhiều lần kiểm tra tính chẵn lẻ từ thuật toán mã Hamming của chúng ta khi tất cả được gói gọn lại thành một thao tác duy nhất.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -384,7 +384,7 @@
   "end": 405.76
  },
  {
-  "input": "For exa We also commonly talk about the XOR of two different bit strings, which basically does this component",
+  "input": "Does that make sense?",
   "translatedText": "Điều đó có ý nghĩa?",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -392,7 +392,7 @@
   "end": 406.8
  },
  {
-  "input": "by component. It's like addition, but where you never carry. Again, the more mathematically inclined might prefer to think of this as adding two vectors and reducing mod 2. If you open up some Python right now, and you a",
+  "input": "Likewise, the next column counts how many positions are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on.",
   "translatedText": "Tương tự, cột tiếp theo đếm số lượng vị trí trong nhóm chẵn lẻ thứ hai, các vị trí có bit thứ hai đến bit cuối cùng là 1 và cũng được đánh dấu, v. v.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -424,7 +424,7 @@
   "end": 436.56
  },
  {
-  "input": "ou and me is that taking the XOR of many different bit strings is effectively a way to compute the parities of a bunch of separate groups, like so with the columns, all in one fell swoop.",
+  "input": "Now once we have it like this, this gives us a really nice way to think about why these four resulting bits at the bottom directly spell out the position of an error.",
   "translatedText": "Bây giờ khi chúng ta đã có nó như thế này, điều này mang lại cho chúng ta một cách thực sự hay để suy nghĩ về lý do tại sao bốn bit kết quả ở phía dưới này trực tiếp đánh vần vị trí của một lỗi.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -432,7 +432,7 @@
   "end": 447.58
  },
  {
-  "input": "This gives us a rather snazzy way to think about the multiple parity checks from our Hamming",
+  "input": "Let's say some bit in this block gets toggled from a 0 to a 1.",
   "translatedText": "Giả sử một số bit trong khối này được chuyển từ 0 sang 1.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -440,7 +440,7 @@
   "end": 451.86
  },
  {
-  "input": "code algorithm as all being packaged together into one single operation. Though at first glance it does look very different. Specifically, write down the 16 positions in binary, like we had before, and now highlight only the positions where the m",
+  "input": "What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error.",
   "translatedText": "Điều đó có nghĩa là vị trí của bit đó hiện sẽ được bao gồm trong tổng XOR, làm thay đổi tổng từ 0 thành thay vào đó là giá trị mới được đưa vào, vị trí của lỗi.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -488,7 +488,7 @@
   "end": 501.44
  },
  {
-  "input": "se last bit is a 1, but we're already limited only to the highlighted positions, so it's effectively counting how many highlighted positions came from the first parity group. hat we'll do. The second check is among the 8 bits on the right half of the grid, at least as we've drawn it here. This time we might use position 2 as a parity bit,",
+  "input": "We'll start by creating a random array of 16 1s and 0s to simulate the data block, and I'll give it the name bits, but of course in practice this would be something we're receiving from a sender, and instead of being random it would be carrying 11 data bits together with 5 parity bits.",
   "translatedText": "Chúng ta sẽ bắt đầu bằng cách tạo một mảng ngẫu nhiên gồm 16 số 1 và 0 để mô phỏng khối dữ liệu và tôi sẽ đặt tên cho nó là các bit, nhưng tất nhiên trong thực tế đây sẽ là thứ chúng tôi nhận được từ người gửi và thay vì ngẫu nhiên nó sẽ mang 11 bit dữ liệu cùng với 5 bit chẵn lẻ.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -504,7 +504,7 @@
   "end": 527.0
  },
  {
-  "input": "ons are in the second parity group, the positions whose second to last bit is a 1, and which are also highlighted, and so on. It's really just a small shift in perspective on the same thing we've been doing. but for right now we're going to assume that there's at m",
+  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i, and then we pull out just the i value, just the index, well it's not that exciting, we just get back those indices 0 through 15.",
   "translatedText": "Vì vậy, nếu sau đó chúng ta tạo một danh sách lặp lại tất cả các cặp này, các cặp trông giống i và sau đó chúng ta chỉ lấy ra giá trị i, chỉ số, thì điều đó không thú vị lắm, chúng ta chỉ lấy lại các chỉ số đó từ 0 đến 15.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -512,7 +512,7 @@
   "end": 541.34
  },
  {
-  "input": "ost one error in the entire block. Things break down completely for more than that. The sender is responsible for toggling some of the special parity bits to make sure the sum works out to be 0000.",
+  "input": "But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then it pulls out only the positions where the corresponding bit is turned on.",
   "translatedText": "Nhưng nếu chúng ta thêm vào điều kiện chỉ thực hiện điều này nếu bit, nghĩa là nếu bit đó là 1 chứ không phải 0, thì nó chỉ lấy ra các vị trí mà bit tương ứng được bật.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -576,7 +576,7 @@
   "end": 601.28
  },
  {
-  "input": "he right What that means is that the position of that bit is now going to be included in the total XOR, which changes the sum from being 0 to instead being this newly included value, the position of the error. Slightly less obviously, the same is true if there's an error that changes a 1 to a 0.",
+  "input": "We won't do it here, but you could write a function where the sender uses that binary representation to set the four parity bits as needed, ultimately getting this block to a state where running this line of code on the full list of bits returns a 0.",
   "translatedText": "Chúng tôi sẽ không làm điều đó ở đây, nhưng bạn có thể viết một hàm trong đó người gửi sử dụng biểu diễn nhị phân đó để đặt bốn bit chẵn lẻ nếu cần, cuối cùng đưa khối này về trạng thái chạy dòng mã này trên danh sách đầy đủ các bit trả về một số 0.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -592,7 +592,7 @@
   "end": 618.2
  },
  {
-  "input": "t's the same as not having it there at all, basically because in this world 1 plus 1 equals 0. So adding a copy of this position to the total sum has the same effect as removing it. And that effect, again, is that the tota",
+  "input": "What's cool is that if we toggle any one of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error.",
   "translatedText": "Điều thú vị là nếu chúng ta chuyển đổi bất kỳ bit nào trong danh sách này, mô phỏng một lỗi ngẫu nhiên do nhiễu, thì nếu bạn chạy cùng dòng mã này, nó sẽ in ra lỗi đó.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -608,7 +608,7 @@
   "end": 631.52
  },
  {
-  "input": "l result at the bottom here spells out the position of the error. To illustrate how elegant this is, let me show that one line of Python code I referenced before, which will capture almost all",
+  "input": "You could get this block from out of the blue, run this single line on it, and it'll automatically spit out the position of an error, or a 0 if there wasn't any.",
   "translatedText": "Bạn có thể lấy khối này bất ngờ, chạy dòng đơn này trên đó và nó sẽ tự động đưa ra vị trí của lỗi hoặc số 0 nếu không có.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -640,7 +640,7 @@
   "end": 663.76
  },
  {
-  "input": "rom a sender, and instead of being random, it would be carrying 11 data bits together with 5 parity bits. If I call the function enumerateBits, what it does is pair together each of those bits with a corresponding index, in this case running from 0 up to 15.",
+  "input": "Now, depending on your comfort with binary and XORs and software in general, you may either find this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go.",
   "translatedText": "Bây giờ, tùy thuộc vào sự thoải mái của bạn với nhị phân, XOR và phần mềm nói chung, bạn có thể thấy quan điểm này hơi khó hiểu hoặc thanh lịch và đơn giản hơn nhiều đến mức bạn đang tự hỏi tại sao chúng ta không bắt đầu với nó ngay từ đầu. -đi.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -648,7 +648,7 @@
   "end": 678.42
  },
  {
-  "input": "So if we then create a list that loops over all of these pairs, pairs that look like i,bit, and then we pull out just the i value, just the index, well, it's not that exciting, we just get back those indices 0 through 15. But if we add on the condition to only do this if bit, meaning if that bit is a 1 and not a 0, well then",
+  "input": "Loosely speaking, the multiple parity check perspective is easier to think about when implementing Hamming codes in hardware very directly, and the XOR perspective is easiest to think about when doing it in software, from kind of a higher level.",
   "translatedText": "Nói một cách lỏng lẻo, phối cảnh kiểm tra tính chẵn lẻ sẽ dễ nghĩ đến hơn khi triển khai mã Hamming trong phần cứng một cách trực tiếp và phối cảnh XOR là dễ nghĩ đến nhất khi thực hiện nó trong phần mềm, từ cấp độ cao hơn.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -664,7 +664,7 @@
   "end": 710.0
  },
  {
-  "input": "e turned on, and then XOR them together. To do this in Python, let me first import a couple helpful functions. That way we can call reduce() on this list, and use the XOR function to reduce it.",
+  "input": "The relevant fact here is that that information directly corresponds to how much redundancy we need.",
   "translatedText": "Thực tế có liên quan ở đây là thông tin đó tương ứng trực tiếp với mức độ dư thừa mà chúng ta cần.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -680,7 +680,7 @@
   "end": 726.54
  },
  {
-  "input": "fact, the astute among you might even notice a connection between these questions and binary counting. And if you do, again let me emphasize, pause, try for yourself t So at the moment, it",
+  "input": "And then, by the way, there is this whole other way that you sometimes see Hamming codes presented, where you multiply the message by one big matrix.",
   "translatedText": "Và sau đó, nhân tiện, có một cách hoàn toàn khác mà đôi khi bạn thấy mã Hamming được trình bày, trong đó bạn nhân thông điệp với một ma trận lớn.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -696,7 +696,7 @@
   "end": 743.06
  },
  {
-  "input": "turns 9, which has the binary representation 1001. We won't do it here, but you could write a function where the sender uses that binary representation to set the 4 parity bits as needed, ultimately getting this block to a",
+  "input": "And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size.",
   "translatedText": "Và nói về việc chia tỷ lệ, bạn có thể nhận thấy rằng hiệu quả của sơ đồ này chỉ trở nên tốt hơn khi chúng tôi tăng kích thước khối.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -704,7 +704,7 @@
   "end": 751.16
  },
  {
-  "input": "state where running this line of code on the full list of bits returns a 0. ed, well, you can just try it. Take a moment to think about how any error among these four special bits is going to be tracked down just like any other, w",
+  "input": "For example, we saw that with 256 bits, you're using only 3% of that space for redundancy, and it just keeps getting better from there.",
   "translatedText": "Ví dụ: chúng tôi thấy rằng với 256 bit, bạn chỉ sử dụng 3% dung lượng đó để dự phòng và nó sẽ ngày càng tốt hơn từ đó.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -712,7 +712,7 @@
   "end": 762.66
  },
  {
-  "input": "ith the same group of four questions. It doesn't really matter, since at the end of the d Now what's cool is that if we toggle any on",
+  "input": "As the number of parity bits grows one by one, the block size keeps doubling.",
   "translatedText": "Khi số lượng bit chẵn lẻ tăng lên từng cái một, kích thước khối tiếp tục tăng gấp đôi.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -720,7 +720,7 @@
   "end": 767.34
  },
  {
-  "input": "e of the bits in this list, simulating a random error from noise, then if you run this same line of code, it prints out that error. correction bits are just riding along. But protecting those bits as well is something that natural You could get this block",
+  "input": "And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
   "translatedText": "Và nếu bạn coi điều đó đến mức cực đoan, bạn có thể có một khối với một triệu bit, trong đó bạn thực sự sẽ chơi 20 câu hỏi với các kiểm tra chẵn lẻ của mình và nó chỉ sử dụng 21 bit chẵn lẻ.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -736,7 +736,7 @@
   "end": 787.06
  },
  {
-  "input": "he position of an error, or a 0 if there wasn't any. hat these questions are in just a minute or two. Hopefully this sketch is enough to appreciate the efficiency of what we're developing here. The first thing, except for those eight highlighted pari",
+  "input": "The problem, of course, is that with a larger block, the probability of seeing more than one or two bit errors goes up, and Hamming codes do not handle anything beyond that.",
   "translatedText": "Tất nhiên, vấn đề là với khối lớn hơn, xác suất nhìn thấy nhiều hơn một hoặc hai bit lỗi sẽ tăng lên và mã Hamming không xử lý được bất kỳ điều gì ngoài điều đó.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -768,7 +768,7 @@
   "end": 838.82
  },
  {
-  "input": "hecks detect an e Now depending on your comfort with binary and XORs and software in general, you may either fi",
+  "input": "But that's a topic for another time.",
   "translatedText": "Nhưng đó là một chủ đề cho một thời điểm khác.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -776,7 +776,7 @@
   "end": 841.34
  },
  {
-  "input": "nd this perspective a little bit confusing, or so much more elegant and simple that you're wondering why we didn't just start with it from the get-go. tended, then it either means there wa",
+  "input": "In his book The Art of Doing Science and Engineering, Hamming is wonderfully candid about just how meandering his discovery of this code was.",
   "translatedText": "Trong cuốn sách Nghệ thuật thực hiện khoa học và kỹ thuật, Hamming đã thẳng thắn một cách tuyệt vời về việc khám phá ra mật mã này của ông đã quanh co như thế nào.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -808,7 +808,7 @@
   "end": 881.22
  },
  {
-  "input": "better job instilling the core intuition underlying all of this, which is that the information required to locate a single error is related to the",
+  "input": "There are like half a dozen times throughout this book that he references the Louis Pasteur quote, luck favors a prepared mind.",
   "translatedText": "Có khoảng nửa tá lần trong suốt cuốn sách này ông đề cập đến câu nói của Louis Pasteur, may mắn sẽ đến với một tâm trí đã chuẩn bị sẵn sàng.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -832,7 +832,7 @@
   "end": 901.3
  },
  {
-  "input": "les. The relevant fact here is that that information directly corresponds to how much redundancy we need. at 0th one so that the parity of the full block is even, just like a normal parity check.",
+  "input": "But you shouldn't fool yourself into thinking that they actually are obvious, because they definitely aren't.",
   "translatedText": "Nhưng bạn không nên tự lừa dối mình rằng chúng thực sự hiển nhiên, bởi vì chúng chắc chắn không phải vậy.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -880,7 +880,7 @@
   "end": 942.54
  },
  {
-  "input": "or where it comes from or how it scales. And speaking of scaling, you might notice that the efficiency of this scheme only gets better as we increase the block size. For example, we saw that with 256 bits, you're using only 3% of that space for redu",
+  "input": "This was the same foundational paper that showed, in a certain sense, that efficient error correction is always possible, no matter how high the probability of bit flips, at least in theory.",
   "translatedText": "Theo một nghĩa nào đó, đây cũng chính là bài báo nền tảng đã chỉ ra rằng luôn có thể sửa lỗi hiệu quả, bất kể xác suất lật bit cao đến đâu, ít nhất là trên lý thuyết.",
   "model": "google_nmt",
   "n_reviews": 0,
@@ -896,7 +896,7 @@
   "end": 961.16
  },
  {
-  "input": "As the number of parity bits grows one by one, the block size keeps doubling. And if you take that to an extreme, you could have a block with, say, a million bits, where you would quite literally be playing 20 questions with your parity checks, and it uses only 21 parity bits.",
+  "input": "Fast forward several decades, and these days, many of us are so immersed in thinking about bits and information that it's easy to overlook just how distinct this way of thinking was.",
   "translatedText": "Nhiều thập kỷ trôi qua nhanh chóng, và ngày nay, nhiều người trong chúng ta quá đắm chìm trong việc suy nghĩ về các bit và thông tin đến mức chúng ta dễ dàng bỏ qua cách suy nghĩ này khác biệt như thế nào.",
   "model": "google_nmt",
   "n_reviews": 0,