diff --git a/luku28.tex b/luku28.tex
index ff3bddc..aef88b7 100644
--- a/luku28.tex
+++ b/luku28.tex
@@ -1,29 +1,22 @@
 \chapter{Segment trees revisited}
 
-\index{segmenttipuu@segmenttipuu}
+\index{segment tree}
 
-Segmenttipuu on tehokas tietorakenne,
-joka mahdollistaa monenlaisten
-kyselyiden toteuttamisen tehokkaasti.
-Tähän mennessä olemme käyttäneet
-kuitenkin segmenttipuuta melko rajoittuneesti.
-Nyt on aika tutustua pintaa syvemmältä
-segmenttipuun mahdollisuuksiin.
+A segment tree is a versatile data structure
+that can be used in many different situations.
+However, there are many topics related to segment trees
+that we haven't touched yet.
+Now it's time to learn some more advanced variations
+of segment trees and see their full potential.
 
-Tähän mennessä olemme kulkeneet segmenttipuuta
-\textit{alhaalta ylöspäin} lehdistä juureen.
-Vaihtoehtoinen tapa toteuttaa puun käsittely
-on kulkea \textit{ylhäältä alaspäin} juuresta lehtiin.
-Tämä kulkusuunta on usein kätevä silloin,
-kun kyseessä on perustilannetta
-monimutkaisempi segmenttipuu.
-
-Esimerkiksi välin $[a,b]$ summan laskeminen
-segmenttipuussa tapahtuu alhaalta ylöspäin 
-tuttuun tapaan näin (luku 9.3):
+So far, we have implemented the operations
+of a segment tree by walking \emph{from the bottom to the top},
+from the leaves to the root.
+For example, we have calculated the sum of a range $[a,b]$
+as follows (Chapter 9.3):
 
 \begin{lstlisting}
-int summa(int a, int b) {
+int sum(int a, int b) {
     a += N; b += N;
     int s = 0;
     while (a <= b) {
@@ -34,51 +27,48 @@ int summa(int a, int b) {
     return s;
 }
 \end{lstlisting}
-Ylhäältä alaspäin toteutettuna funktiosta tulee:
+However, in more advanced segment trees,
+it's beneficial to implement the operations
+in another way, \emph{from the top to the bottom},
+from the root to the leaves.
+Using this approach, the function becomes as follows:
 
 \begin{lstlisting}
-int summa(int a, int b, int k, int x, int y) {
+int sum(int a, int b, int k, int x, int y) {
     if (b < x || a > y) return 0;
     if (a == x && b == y) return p[k];
     int d = (y-x+1)/2;
-    return summa(a, min(x+d-1,b), 2*k, x, x+d-1) +
-           summa(max(x+d,a), b, 2*k+1, x+d, y);
+    return sum(a, min(x+d-1,b), 2*k, x, x+d-1) +
+           sum(max(x+d,a), b, 2*k+1, x+d, y);
 }
 \end{lstlisting}
-Nyt välin $[a,b]$ summan saa laskettua
-kutsumalla funktiota näin:
+Now we can calulate the sum of the range $[a,b]$
+as follows:
 
 \begin{lstlisting}
-int s = summa(a, b, 1, 0, N-1);
+int s = sum(a, b, 1, 0, N-1);
 \end{lstlisting}
+The parameter $k$ is the current position
+in array \texttt{p}.
+Initially $k$ equals 1, because we begin
+at the root of the segment tree.
+The range $[x,y]$ corresponds to $k$,
+and is initially $[0,N-1]$.
+If $[a,b]$ is outside $[x,y]$,
+the sum of the range is 0,
+and if $[a,b]$ equals $[x,y]$,
+the sum can be found in array \texttt{p}.
+If $[a,b]$ is completely or partially inside $[x,y]$,
+the search continues recursively to the
+left and right half of $[x,y]$.
+The size of both halves is $d=\frac{1}{2}(y-x+1)$;
+the left half is $[x,x+d-1]$
+and the right half is $[x+d,y]$.
 
-Parametri $k$ ilmaisee kohdan
-taulukossa \texttt{p}.
-Aluksi $k$:n arvona on 1,
-koska summan laskeminen alkaa
-segmenttipuun juuresta.
-
-Väli $[x,y]$ on parametria $k$ vastaava väli,
-aluksi koko kyselyalue eli $[0,N-1]$.
-Jos väli $[a,b]$ on välin $[x,y]$
-ulkopuolella, välin summa on 0.
-Jos taas välit $[a,b]$ ja $[x,y]$
-ovat samat, summan saa taulukosta \texttt{p}.
-
-Jos väli $[a,b]$ on kokonaan tai osittain välin $[x,y]$
-sisällä, haku jatkuu rekursiivisesti
-välin $[x,y]$ vasemmasta ja oikeasta puoliskosta.
-Kummankin puoliskon koko on $d=\frac{1}{2}(y-x+1)$,
-joten vasen puolisko kattaa välin $[x,x+d-1]$
-ja oikea puolisko kattaa välin $[x+d,y]$.
-
-Seuraava kuva näyttää,
-kuinka haku etenee puussa,
-kun lasketaan puun alle
-merkityn välin summa.
-Harmaat solmut ovat kohtia,
-joissa rekursio päättyy ja välin
-summan saa taulukosta \texttt{p}.
+The following picture shows how the search proceeds
+when calculating the sum of the marked elements.
+The gray nodes indicate nodes where the recursion
+stops and the sum of the range can be found in array \texttt{p}.
 \\
 \begin{center}
 \begin{tikzpicture}[scale=0.7]
@@ -169,59 +159,61 @@ summan saa taulukosta \texttt{p}.
 \draw [decoration={brace}, decorate, line width=0.5mm] (14,-0.25) -- (5,-0.25);
 \end{tikzpicture}
 \end{center}
-Myös tässä toteutuksessa kyselyn aikavaativuus on $O(\log n)$,
-koska haun aikana käsiteltävien solmujen määrä on $O(\log n)$.
+Also in this implementation,
+the time complexity of a range query is $O(\log n)$,
+because the total number of processed nodes is $O(\log n)$.
 
-\section{Laiska eteneminen}
+\section{Lazy propagation}
 
-\index{laiska eteneminen@laiska eteneminen}
-\index{laiska segmenttipuu@laiska segmenttipuu}
+\index{lazy propagation}
+\index{lazy segment tree}
 
-\key{Laiska eteneminen}
-mahdollistaa segmenttipuun,
-jossa voi sekä muuttaa väliä että kysyä tietoa väliltä
-ajassa $O(\log n)$.
-Ideana on suorittaa muutokset ja kyselyt ylhäältä
-alaspäin ja toteuttaa muutokset laiskasti niin,
-että ne välitetään puussa alaspäin vain silloin,
-kun se on välttämätöntä.
+Using \key{lazy propagation}, we can construct
+a segment tree that supports both range updates
+and range queries in $O(\log n)$ time.
+The idea is to perform the updates and queries
+from the top to the bottom, and process the updates
+\emph{lazily} so that they are propagated
+down the tree only when it is necessary.
 
-Laiskassa segmenttipuussa solmuihin liittyy
-kahdenlaista tietoa.
-Kuten tavallisessa segmenttipuussa,
-jokaisessa solmussa on sitä vastaavan välin
-summa tai muu haluttu tieto.
-Tämän lisäksi solmussa voi olla laiskaan etenemiseen
-liittyvää tietoa, jota ei ole vielä välitetty
-solmusta alaspäin.
+In a lazy segment tree, nodes contain two types of
+information.
+Like in a normal segment tree,
+each node contains the sum or some other value
+of the corresponding subarray.
+In addition, the node may contain information
+related to lazy updates, which has not been
+propagated yet to its children.
 
-Välin muutostapa voi olla joko
-\textit{lisäys} tai \textit{asetus}.
-Lisäyksessä välin jokaiseen alkioon lisätään
-tietty arvo, ja asetuksessa välin
-jokainen alkio saa tietyn arvon.
-Kummankin operaation toteutus on melko samanlainen,
-ja puu voi myös sallia samaan aikaan
-molemmat muutostavat.
+There are two possible types for range updates:
+\emph{addition} and \emph{insertion}.
+In addition, each element in the range is
+increased by some value,
+and in insertion, each element in the range
+is assigned some value.
+Both operations can be implemented using
+similar ideas, and it's possible to construct
+a tree that supports both the operations
+simultaneously.
 
-\subsubsection{Laiska segmenttipuu}
+\subsubsection{Lazy segment tree}
+
+Let's consider an example where our goal is to
+construct a segment tree that supports the following operations:
 
-Tarkastellaan esimerkkinä tilannetta,
-jossa segmenttipuun
-tulee toteuttaa seuraavat operaatiot:
 \begin{itemize}
-\item lisää jokaisen välin $[a,b]$ alkioon arvo $u$
-\item laske välin $[a,b]$ alkioiden summa
+\item increase each element in $[a,b]$ by $u$
+\item calculate the sum of elements in $[a,b]$
 \end{itemize}
-Toteutamme puun, jonka jokaisessa
-solmussa on kaksi arvoa $s/z$:
-välin lukujen summa $s$,
-kuten tavallisessa segmenttipuussa, sekä
-laiska muutos $z$,
-joka tarkoittaa,
-että kaikkiin välin lukuihin tulee lisätä $z$.
-Seuraavassa puussa jokaisessa solmussa $z=0$
-eli mitään muutoksia ei ole kesken.
+We will construct a tree where each node
+contains two values $s/z$:
+$s$ denotes the sum of elements in the range,
+like in a standard segment tree,
+and $z$ denotes a lazy update,
+which means that all elements in the range
+should be increased by $z$.
+In the following tree, $z=0$ for all nodes,
+so there are no lazy updates.
 \begin{center}
 \begin{tikzpicture}[scale=0.7]
 \draw (0,0) grid (16,1);
@@ -294,19 +286,19 @@ eli mitään muutoksia ei ole kesken.
 \end{tikzpicture}
 \end{center}
 
-Kun välin $[a,b]$ solmuja kasvatetaan $u$:lla,
-alkaa kulku puun juuresta lehtiä kohti.
-Kulun aikana tapahtuu kahdenlaisia muutoksia puun solmuihin:
+When a range $[a,b]$ is increased by $u$,
+we walk from the root towards the leaves
+and modify the nodes in the tree as follows:
+If the range $[x,y]$ of a node is
+completely inside the range $[a,b]$,
+we increase the $z$ value of the node by $u$ and stop.
+However, if $[x,y]$ only partially belongs to $[a,b]$,
+we increase the $s$ value of the node by $hu$,
+where $h$ is the size of the intersection of $[a,b]$
+and $[x,y]$, and continue our walk recursively in the tree.
 
-Jos solmun väli $[x,y]$ kuuluu kokonaan
-muutettavalle välille $[a,b]$,
-solmun $z$-arvo kasvaa $u$:llä ja kulku pysähtyy.
-Jos taas väli $[x,y]$ kuuluu osittain välille $[a,b]$,
-solmun $s$-arvo kasvaa $hu$:llä,
-missä $h$ on välien $[a,b]$ ja $[x,y]$ yhteisen osan pituus,
-ja kulku jatkuu rekursiivisesti alaspäin.
-
-Kasvatetaan esimerkiksi puun alle merkittyä väliä 2:lla:
+For example, the following picture shows the tree after
+increasing the elements in the range marked at the bottom by 2:
 \begin{center}
 \begin{tikzpicture}[scale=0.7]
 \fill[color=gray!50] (5,0) rectangle (6,1);
@@ -395,23 +387,24 @@ Kasvatetaan esimerkiksi puun alle merkittyä väliä 2:lla:
 \end{tikzpicture}
 \end{center}
 
-Välin $[a,b]$ summan laskenta tapahtuu myös
-kulkuna puun juuresta lehtiä kohti.
-Jos solmun väli $[x,y]$ kuuluu kokonaan väliin $[a,b]$,
-kyselyn summaan lisätään solmun $s$-arvo
-sekä mahdollinen $z$-arvon tuottama lisäys.
-Muussa tapauksessa kulku jatkuu rekursiivisesti alaspäin solmun lapsiin.
+We also calculate the sum in a range $[a,b]$
+by walking in the tree from the root towards the leaves.
+If the range $[x,y]$ of a node completely belongs
+to $[a,b]$, we add the $s$ value of the node to the sum.
+Otherwise, we continue the search recursively
+downwards in the tree.
 
-Aina ennen solmun käsittelyä siinä mahdollisesti
-oleva laiska muutos välitetään tasoa alemmas.
-Tämä tapahtuu sekä välin muutoskyselyssä
-että summakyselyssä.
-Ideana on, että laiska muutos etenee alaspäin
-vain silloin, kun tämä on välttämätöntä,
-jotta puun käsittely on tehokasta.
+Always before processing a node,
+the value of the lazy update is propagated
+to the children of the node.
+This happens both in a range update
+and a range query.
+The idea is that the lazy update will be propagated
+downwards only when it is necessary,
+so that the operations are always efficient.
 
-Seuraava kuva näyttää, kuinka äskeinen puu muuttuu,
-kun siitä lasketaan puun alle merkityn välin summa:
+The following picture shows how the tree changes
+when we calculate the sum in the marked range:
 \begin{center}
 \begin{tikzpicture}[scale=0.7]
 \draw (0,0) grid (16,1);
@@ -495,52 +488,54 @@ kun siitä lasketaan puun alle merkityn välin summa:
 \draw[color=blue,thick] (8,1.5) rectangle (12,5.5);
 \end{tikzpicture}
 \end{center}
-Tämän kyselyn seurauksena laiska muutos eteni alaspäin
-laatikolla ympäröidyssä puun osassa.
-Laiskaa muutosta täytyi viedä alaspäin, koska kyselyn
-kohteena oleva väli osui osittain laiskan muutoksen välille.
+The result of this query was that a lazy update was
+propagated downwards in the nodes that are inside the rectangle.
+It was necessary to propagate the lazy update,
+because some of the updated elements were inside the range.
 
-Huomaa, että joskus puussa olevia laiskoja muutoksia täytyy yhdistää.
-Näin tapahtuu silloin, kun solmussa on valmiina laiska muutos
-ja siihen tulee ylhäältä toinen laiska muutos.
-Tässä tapauksessa yhdistäminen on helppoa,
-koska muutokset $z_1$ ja $z_2$ aiheuttavat yhdessä muutoksen $z_1+z_2$.
+Note that sometimes it's necessary to combine lazy updates.
+This happens when a node already has a lazy update,
+and another lazy update will be added to it.
+In the above tree, it's easy to combine lazy updates
+because updates $z_1$ and $z_2$ combined equal to update $z_1+z_2$.
 
-\subsubsection{Polynomimuutos}
+\subsubsection{Polynomial update}
 
-Laiskaa segmenttipuuta voi yleistää niin,
-että väliä muuttaa polynomi
+A lazy update can be generalized so that it's
+allowed to update a range by a polynomial
 \[p(u) = t_k u^k + t_{k-1} u^{k-1} + \cdots + t_0.\]
 
-Ideana on, että välin ensimmäisen kohdan
-muutos on $p(0)$, toisen kohdan muutos on $p(1)$ jne.,
-eli välin $[a,b]$ kohdan $i$ muutos on $p(i-a)$.
-Esimerkiksi polynomin $p(u)=u+1$ lisäys välille
-$[a,b]$ tarkoittaa, että kohta $a$ kasvaa 1:llä,
-kohta $a+1$ kasvaa 2:lla, kohta $a+2$ kasvaa 3:lla jne.
+Here, the update for the first element in the range is $p(0)$,
+for the second element $p(1)$, etc., so the update
+at index $i$ in range $[a,b]$ is $p(i-a)$.
+For example, adding a polynomial $p(u)=u+1$
+to range $[a,b]$ means that the element at index $a$
+increases by 1, the element at index $a+1$
+increases by 2, etc.
 
-Polynomimuutoksen voi toteuttaa niin,
-että jokaisessa solmussa on $k+2$ arvoa,
-missä $k$ on polynomin asteluku.
-Arvo $s$ kertoo solmua vastaavan välin summan kuten ennenkin,
-ja arvot $z_0,z_1,\ldots,z_k$ ovat polynomin kertoimet,
-joka ilmaisee väliin kohdistuvan laiskan muutoksen.
+A polynomial update can be supported by
+storing $k+2$ values to each node where $k$
+equals the degree of the polynomial.
+The value $s$ is the sum of the elements in the range,
+and values $z_0,z_1,\ldots,z_k$ are the coefficients
+of a polynomial that corresponds to a lazy update.
 
-Nyt välin $[x,y]$ summa on
+Now, the sum of $[x,y]$ is
 \[s+\sum_{u=0}^{y-x} z_k u^k + z_{k-1} u^{k-1} + \cdots + z_0,\]
-jonka saa laskettua tehokkaasti osissa summakaavoilla.
-Esimerkiksi termin $z_0$ summaksi tulee
-$(y-x+1)z_0$ ja termin $z_1 u$ summaksi tulee
+that can be efficiently calculated using sum formulas
+For example, the value $z_0$ corresponds to the sum
+$(y-x+1)z_0$, and the value $z_1 u$ corresponds to the sum
 \[z_1(0+1+\cdots+y-x) = z_1 \frac{(y-x)(y-x+1)}{2} .\]
 
-Kun muutos etenee alaspäin puussa,
-polynomin $p(u)$ indeksointi muuttuu,
-koska jokaisella välillä $[x,y]$
-polynomin arvot tulevat kohdista $x=0,1,\ldots,y-x$.
-Tämä ei kuitenkaan tuota ongelmia,
-koska $p'(u)=p(u+h)$ on aina
-samanasteinen polynomi kuin $p(u)$.
-Esimerkiksi jos $p(u)=t_2 u^2+t_1 u-t_0$, niin
+When propagating an update in the tree,
+the indices of the polynomial $p(u)$ change,
+because in each range $[x,y]$,
+the values are
+calculated for $x=0,1,\ldots,y-x$.
+However, this is not a problem, because
+$p'(u)=p(u+h)$ is a polynomial
+of equal degree as $p(u)$.
+For example, if $p(u)=t_2 u^2+t_1 u-t_0$, then
 \[p'(u)=t_2(u+h)^2+t_1(u+h)-t_0=t_2 u^2 + (2ht_2+t_1)u+t_2h^2+t_1h-t_0.\]
 
 \section{Dynaaminen toteutus}