diff --git a/Session.vim b/Session.vim
index c437a43..806b0f7 100644
--- a/Session.vim
+++ b/Session.vim
@@ -13,19 +13,21 @@ if &shortmess =~ 'A'
 else
   set shortmess=aoO
 endif
-badd +128 content/BACH.typ
+badd +183 content/BACH.typ
 badd +1 glossary.typ
 badd +1 bibliography.bib
-badd +0 \$
-badd +6 pseudocode/bach_1.typ
+badd +1 \$
+badd +14 pseudocode/bach_1.typ
 badd +265 content/SMHD.typ
 badd +7 pseudocode/bach_find_best_appr.typ
+badd +60 content/introduction.typ
 argglobal
 %argdel
 set stal=2
 tabnew +setlocal\ bufhidden=wipe
 tabnew +setlocal\ bufhidden=wipe
 tabnew +setlocal\ bufhidden=wipe
+tabnew +setlocal\ bufhidden=wipe
 tabrewind
 edit content/BACH.typ
 argglobal
@@ -40,11 +42,31 @@ setlocal fdn=20
 setlocal fen
 silent! normal! zE
 let &fdl = &fdl
-let s:l = 164 - ((38 * winheight(0) + 25) / 50)
+let s:l = 88 - ((17 * winheight(0) + 25) / 50)
 if s:l < 1 | let s:l = 1 | endif
 keepjumps exe s:l
 normal! zt
-keepjumps 164
+keepjumps 88
+normal! 0102|
+tabnext
+edit content/introduction.typ
+argglobal
+balt content/BACH.typ
+setlocal fdm=manual
+setlocal fde=0
+setlocal fmr={{{,}}}
+setlocal fdi=#
+setlocal fdl=0
+setlocal fml=1
+setlocal fdn=20
+setlocal fen
+silent! normal! zE
+let &fdl = &fdl
+let s:l = 56 - ((41 * winheight(0) + 25) / 50)
+if s:l < 1 | let s:l = 1 | endif
+keepjumps exe s:l
+normal! zt
+keepjumps 56
 normal! 0
 tabnext
 edit glossary.typ
@@ -105,9 +127,7 @@ set winheight=1
 set winminwidth=0
 set winwidth=1
 exe '1resize ' . ((&lines * 25 + 26) / 53)
-exe 'vert 1resize ' . ((&columns * 129 + 105) / 211)
 exe '2resize ' . ((&lines * 24 + 26) / 53)
-exe 'vert 2resize ' . ((&columns * 129 + 105) / 211)
 argglobal
 balt bibliography.bib
 setlocal fdm=manual
@@ -120,12 +140,12 @@ setlocal fdn=20
 setlocal fen
 silent! normal! zE
 let &fdl = &fdl
-let s:l = 16 - ((15 * winheight(0) + 12) / 25)
+let s:l = 12 - ((11 * winheight(0) + 12) / 25)
 if s:l < 1 | let s:l = 1 | endif
 keepjumps exe s:l
 normal! zt
-keepjumps 16
-normal! 0
+keepjumps 12
+normal! 068|
 wincmd w
 argglobal
 if bufexists(fnamemodify("pseudocode/bach_find_best_appr.typ", ":p")) | buffer pseudocode/bach_find_best_appr.typ | else | edit pseudocode/bach_find_best_appr.typ | endif
@@ -151,10 +171,8 @@ keepjumps 7
 normal! 031|
 wincmd w
 exe '1resize ' . ((&lines * 25 + 26) / 53)
-exe 'vert 1resize ' . ((&columns * 129 + 105) / 211)
 exe '2resize ' . ((&lines * 24 + 26) / 53)
-exe 'vert 2resize ' . ((&columns * 129 + 105) / 211)
-tabnext 1
+tabnext 5
 set stal=1
 if exists('s:wipebuf') && len(win_findbuf(s:wipebuf)) == 0 && getbufvar(s:wipebuf, '&buftype') isnot# 'terminal'
   silent exe 'bwipe ' . s:wipebuf
diff --git a/content/BACH.typ b/content/BACH.typ
index 41601cf..2af008a 100644
--- a/content/BACH.typ
+++ b/content/BACH.typ
@@ -104,12 +104,12 @@ Its cardinality is $2^M$, while $M$ defines the number of bits we want to extrac
 It has to be noted, that $bold(cal(o))$ consists of optimal values that we may not be able to exactly approximate using a linear combination based on weights and our given input values. 
 
 In comparison to the 1-bit sign-based quantization, we will not be able to find a linear combination of only two input values that approximates the optimal points we defined earlier.
-Therefore, we will use -- without any loss of generality -- three summands for the linear combination as this give us more flexible control over the result of the linear combination with the helper data. 
+Therefore, we will use three or more summands for the linear combination as this give us more flexible control over the result of the linear combination with the helper data. 
 Later we will be able to show that a higher number of summands for $z$ can provide better approximations for the ideal values of $z$ at the expense of the number of available input values for the quantizer. 
 
 We will define $z$ from now on as:
 $
-z = x_1 dot h_1 plus x_2 dot h_2 plus x_3 dot h_3.
+z = sum_(i=3)^n x_i dot h_i
 $<eq:z_eq>
 
 We can now find the optimal linear combination $z_"opt"$ by finding the minimum of all distances to all optimal points defined as $bold(cal(o))$.
@@ -161,4 +161,23 @@ We can now use an iterative algorithm that alternates between optimizing the qua
     kind: "algorithm",
     supplement: [Algorithm],
     include("../pseudocode/bach_1.typ")
-)
+)<alg:bach_1>
+
+We can see both of these alternating parts in @alg:bach_1_2[Lines] and @alg:bach_1_3[] of @alg:bach_1. 
+To optimize the quantizing bounds of $cal(Q)$, we will sort the values of all the resulting linear combinations $bold(z)_"opt"$ in ascending order. 
+Using the inverse @ecdf defined in @eq:ecdf_inverse, we can find new quantizer bounds based on $bold(z)_"opt"$ from the first iteration.
+These bounds will then be used to define a new set of optimal points $bold(cal(o))$ used for the next iteration. 
+During every iteration of @alg:bach_1, we will store all weights $bold(h)$ used to generate the vector for optimal linear combinations $bold(z)_"opt"$. 
+
+The output of @alg:bach_1 is the vector of optimal weights $bold(h)_"opt"$.
+$bold(h)_"opt"$ can now be used to complete the enrollment phase and quantize the values $bold(z)_"opt"$.
+
+=== Maximum quantizing bound distance approximation
+
+Instead of defining the optimal positions for $z$ with fixed values, we can also provide a more loose definition of $bold(cal(o))$.
+Let's consider the following example: 
+
+
+== Experiments 
+
+== Results & Discussion
diff --git a/content/introduction.typ b/content/introduction.typ
index 709ae46..aa476f3 100644
--- a/content/introduction.typ
+++ b/content/introduction.typ
@@ -1,3 +1,4 @@
+#import "@preview/glossarium:0.4.1": * 
 = Introduction
 
 These are the introducing words
@@ -39,6 +40,23 @@ This transformation can be performed using the function $xi = tilde(x)$. The key
 Considering a normal distribution, the CDF is defined as 
 $ xi(frac(x - mu, sigma)) = frac(1, 2)[1 + \e\rf(frac(x - mu, sigma sqrt(2)))] $
 
-==== ECDF
+==== #gls("ecdf", display: "Empirical cumulative distribution function (eCDF)")
+
+The @ecdf is constructed through sorting the empirical measurements of a distribution @dekking2005modern. Although less accurate, this method allows a more simple and less computationally complex way to transform real valued measurements into the Tilde-Domain. We will mainly use the eCDF in @chap:smhd because of the difficulty of finding an analytical description for the CDF of a Gaussian-Mixture.\
+To apply it, we will sort the vector of realizations $bold(z)$ of a random distributed variable $Z$ in ascending order. 
+The function for an @ecdf can be defined as
+$
+xi_#gls("ecdf") (x) = frac("number of elements in " bold(z)", that" <= x, n) in [0, 1],
+$<eq:ecdf_def>
+where $n$ defines the number of elements in the vector $bold(z)$.
+If the vector $bold(z)$ were to contain the elements $[1, 3, 4, 5, 7, 9, 10]$ and $x = 5$, @eq:ecdf_def would result to $xi_#gls("ecdf") (5) = frac(4, 7)$.\
+The application of @eq:ecdf_def on $X$ will transform its values into the empirical tilde-domain.
+
+We can also define an inverse @ecdf: 
+
+$
+xi_#gls("ecdf")^(-1) (tilde(x)) =  tilde(x) dot n
+$<eq:ecdf_inverse>
+
+The result of @eq:ecdf_inverse is the index $i$ of the element $z_i$ from the vector of realizations $bold(z)$.
 
-The eCDF is constructed through sorting the empirical measurements of a distribution @dekking2005modern. Although less accurate, this method allows a more simple and less computationally complex way to transform real valued measurements into the Tilde-Domain. We will mainly use the eCDF in @chap:smhd because of the difficulty of finding an analytical description for the CDF of a Gaussian-Mixture.
diff --git a/main.pdf b/main.pdf
index 3971796..f334d7f 100644
Binary files a/main.pdf and b/main.pdf differ
diff --git a/pseudocode/bach_1.typ b/pseudocode/bach_1.typ
index 254d79b..81bc058 100644
--- a/pseudocode/bach_1.typ
+++ b/pseudocode/bach_1.typ
@@ -5,12 +5,12 @@
   + *input*: $bold(cal(o))_"first", bold(x), t, M$
   + *lists*: optimal weights $bold(h)_"opt"$
   + $bold(cal(o)) arrow.l bold(cal(o))_"first"$
-  + *repeat* t times: 
+  + #line-label(<alg:bach_1_1>) *repeat* t times: 
     + *perform* @alg:best_appr for all input values with $bold(cal(o))$:
       + *update* $bold(h)_"opt"$ with returned weights
       + $bold(z)_"opt" arrow.l$ all returned linear combinations 
-    + *sort* $bold(z)_"opt"$ in ascending order
-    + *define* new quantizer $cal(Q)^*$ using the @ecdf based on $bold(z)_"opt"$
-    + *update* $bold(cal(o))$ with newly found quantizer step centers
+    + #line-label(<alg:bach_1_2>) *sort* $bold(z)_"opt"$ in ascending order
+    + #line-label(<alg:bach_1_3>) *define* new quantizer $cal(Q)^*$ using the @ecdf based on $bold(z)_"opt"$
+    + #line-label(<alg:bach_1_4>) *update* $bold(cal(o))$ with newly found quantizer step centers
   + *return* $bold(h)_"opt"$ 
 ]