diff --git a/6/krzywa.rb b/6/krzywa.rb
index 85b0488..94b1a32 100755
--- a/6/krzywa.rb
+++ b/6/krzywa.rb
@@ -33,9 +33,7 @@ def generatorKrzywej(p)
   b = 0
 
   while true
-    #p = generate(300)
-
-    if primalityTest(p)
+    if primalityTest(p) &&  p % 4 == 3
       threads = []
 
       threads << Thread.new {
@@ -62,7 +60,14 @@ def punktNaKrzywej(a,b,p)
        x = SecureRandom.random_number(1..p-1)
        fx = rownanieKrzywej(a,b,p,x)
        if remSqEuler(fx,p)
-         y = Math.sqrt(fx).to_i #betterExponentiation(x,((p+1)/4),p)
+         if a == 0
+          y = 0
+         elsif p == 2
+          y = p
+         elsif p % 4 == 3
+          y = Math.sqrt(fx).to_i % p
+          #y = betterExponentiation(a,(p+1/4),p)
+         end
          return x,y
        end
      end
@@ -84,7 +89,31 @@ def punktPrzeciwny(x,y)
 end
 
 def sumaPunktow(a,b,p,x1,y1,x2,y2)
-  
+  # P + Q = R
+  if (x1 != x2) && (y1 != y2)
+    alpha = (((y2 - y1) % p) * reciprocal_Phi_p((x2 - x1),p)) % p
+    x3 = (betterExponentiation(alpha,2,p) - (x1 % p) - (x2 % p)) % p 
+    y3 = (alpha * (x1 - x3) - y1) % p
+    return x3,y3
+  end
+  # P + -Q = 0 DZIALA
+  if (x1 == x2) && (y1 == -y2)
+    return "0"
+  end
+  # P + P = 2P DZIALA
+  if (x1 == x2) && (y1 == y2)
+    alpha = (((3 * betterExponentiation(x1,2,p) % p + a) % p) * reciprocal_Phi_p(2 * y1,p)) % p
+    x3 = betterExponentiation(alpha,2,p) - (x1 % p) - (x2 % p)
+    y3 = (alpha * (x1 - x3) - y1) % p
+    return x3,y3
+  end
+  # 0 - element neutrany --> P + 0 = P
+  if (x1 == 0 && y1 == 0 )
+    return x2,y2
+  elsif (x2 == 0 && y2 == 0)
+    return x1,y1
+  end
+    
 end
 
 #puts generatorKrzywej(11).inspect
@@ -92,3 +121,39 @@ end
 #puts czyPunktNalezyDoKrzywej(2,7,11,7,1).inspect
 #puts czyPunktNalezyDoKrzywej(2,7,11,2,2).inspect
 #puts punktPrzeciwny(2,2).inspect
+#puts sumaPunktow(2,2,17,5,1,5,1).inspect
+
+##################################################
+# Zadania z konca wykladu suma punktow
+#
+# Niech E/F7 będzie postaci
+# E : Y^2 = X^3 + 1
+#
+# Niech P=(1,3)  Q=(2,4)  R=(6,0)
+#
+# Obliczyc:
+# 1) -Q
+# 2) R + [0,0]
+# 3) P + Q
+# 4) 2R
+#
+##################################################
+# Rozwiązanie:
+a = 0
+b = 1
+p = 7
+
+xp = 1
+yp = 3
+
+xq = 2
+yq = 4
+
+xr = 6
+yr = 0
+
+puts punktPrzeciwny(2,4).inspect
+puts sumaPunktow(a,b,p,xr,yr,0,0).inspect
+puts sumaPunktow(a,b,p,xp,yp,xq,yq).inspect
+puts sumaPunktow(a,b,p,xp,yp,xp,yp).inspect
+##################################################
diff --git a/module.rb b/module.rb
index b4f6b4d..12674d7 100755
--- a/module.rb
+++ b/module.rb
@@ -13,6 +13,13 @@ require 'securerandom'
 require 'prime'
 require 'thread'
 
+####################################
+# Funkcja nwd(a,b)
+#
+# Oblicza nwd podanych liczb np
+# nwd(10,14) => 2
+#
+####################################
 def nwd(a, b)
   if a == 0
     return false
@@ -20,6 +27,14 @@ def nwd(a, b)
   b == 0 ? a : nwd(b, a.modulo(b))
 end
 
+####################################
+# Funkcja extended_euklides(a,b)
+#
+# Oblicza rozszerzony algorytm euklidesa
+# zwracajac u,v
+# extended_euklides(10,14) => [3, -2]
+#
+#####################################
 def extended_euklides(a, b)
   return 1, 0 if b == 0
 
@@ -29,7 +44,13 @@ def extended_euklides(a, b)
   return t, s - q * t
 end
 
-# Zad. 1.1
+####################################
+# Funkcja nwd(a,b)
+#
+# Oblicza nwd podanych liczb np
+# nwd(10,14) => 2
+#
+####################################
 def random_gen_Zn(k,n)
 
   if n == 0
@@ -57,19 +78,37 @@ def random_gen_Zn(k,n)
   end
 end
 
-# Zad. 1.2
+####################################
+# Funkcja nwd(a,b)
+#
+# Oblicza nwd podanych liczb np
+# nwd(10,14) => 2
+#
+####################################
 def reciprocal_Phi_p(n,p)
   u = extended_euklides(n,p)[0]
   v = extended_euklides(n,p)[1]
 
-  if u * n % p == 1
+  if (u * n % p) == 1
+    if u < 0
+      return u + p
+    end
     return u
   else
+    if v < 0
+      return v + p
+    end
     return v
   end
 end
 
-# Zad. 1.3
+####################################
+# Funkcja nwd(a,b)
+#
+# Oblicza nwd podanych liczb np
+# nwd(10,14) => 2
+#
+####################################
 def betterExponentiation(x,k,n)
   if n == 0
     return false
@@ -92,7 +131,13 @@ def betterExponentiation(x,k,n)
   end
 end
 
-# Zad. 1.4
+####################################
+# Funkcja nwd(a,b)
+#
+# Oblicza nwd podanych liczb np
+# nwd(10,14) => 2
+#
+####################################
 def remSqEuler(a,p)
   ans = betterExponentiation(a,(p-1)/2,p)
 
@@ -103,7 +148,13 @@ def remSqEuler(a,p)
   end
 end
 
-# Zad. 1.5
+####################################
+# Funkcja nwd(a,b)
+#
+# Oblicza nwd podanych liczb np
+# nwd(10,14) => 2
+#
+####################################
 def squareRootFp(p,b)
   if p % 4 == 3 && remSqEuler(p,b) == true
       a = betterExponentiation(b, (p+1)/4, p)
@@ -111,7 +162,13 @@ def squareRootFp(p,b)
   end
 end
 
-# Zad. 1.6
+####################################
+# Funkcja nwd(a,b)
+#
+# Oblicza nwd podanych liczb np
+# nwd(10,14) => 2
+#
+####################################
 def primalityTest(n)
   if n == 1
     return false
@@ -132,6 +189,13 @@ def primalityTest(n)
   return true
 end
 
+####################################
+# Funkcja nwd(a,b)
+#
+# Oblicza nwd podanych liczb np
+# nwd(10,14) => 2
+#
+####################################
 def specyficPrimaryNumber
   p = 0
   q = 0
@@ -156,6 +220,13 @@ def specyficPrimaryNumber
   end
 end
 
+####################################
+# Funkcja nwd(a,b)
+#
+# Oblicza nwd podanych liczb np
+# nwd(10,14) => 2
+#
+####################################
 def generator(p,q)
   while true
     g = SecureRandom.random_number(2..p-2)
@@ -167,6 +238,13 @@ def generator(p,q)
   end
 end
 
+####################################
+# Funkcja nwd(a,b)
+#
+# Oblicza nwd podanych liczb np
+# nwd(10,14) => 2
+#
+####################################
 def generate(n)
   return `openssl prime -generate -bits '#{n}'`.gsub(/\n$/, '').to_i
 end