diff --git a/as_covers/as_cover_class.sage b/as_covers/as_cover_class.sage
index 736b10b..27d63ec 100644
--- a/as_covers/as_cover_class.sage
+++ b/as_covers/as_cover_class.sage
@@ -1,6 +1,7 @@
 class as_cover:
     def __init__(self, C, cover_template, list_of_fcts, branch_points = [], prec = 10):
         self.quotient = C
+        self.cover_template = cover_template
         self.functions = list_of_fcts
         print('a')
         self.height = len(list_of_fcts)
@@ -77,17 +78,38 @@ class as_cover:
         self.z = [as_function(self, z[j]) for j in range(n)]
         self.dx = as_form(self, 1)
         self.one = as_function(self, 1)
+        Rzf, zgen, fgen = cover_template.fct_field
+        subs_fs = {zgen[i] : z[i]}| {fgen[i] : RxyzQ(list_of_fcts[i].function) for i in range(n)}
+        self.rhs = [RxyzQ(cover_template.fcts[i].subs(subs_fs)) for i in range(n)]
+        #####
+        ##### We compute now the differentials dz[i]
+        y_super = superelliptic_function(C, y)
+        dy_super = y_super.diffn().form
+        dz = []
+        for i in range(n):
+            aux_fct = self.rhs[i]
+            result = 0
+            for j in range(i):
+                result += aux_fct.derivative(z[j])*dz[j]
+            result += aux_fct.derivative(x)
+            result += aux_fct.derivative(y)*dy_super
+            dz += [-result]
+        self.dz = dz
+        
+        
         
         
     def __repr__(self):
         n = self.height
         p = self.characteristic
-        if n==1:
-            return "(Z/p)-cover of " + str(self.quotient)+" with the equation:\n z^" + str(p) + " - z = " + str(self.functions[0])
-        
-        result = "(Z/p)^"+str(self.height)+ "-cover of " + str(self.quotient)+" with the equations:\n"
+        result = str(self.group)
+        result += "-cover of " + str(self.quotient)+" with the equations: \n"
         for i in range(n):
-            result += 'z' + str(i) + "^" + str(p) + " - z" + str(i) + " = " + str(self.functions[i]) + "\n"
+            result += 'z'+str(i)+'^p - z'+str(i) + ' = '
+            aux = str(self.cover_template.fcts[i])
+            for t in range(n):
+                aux = aux.replace("f"+str(t), "(" + str(self.functions[t]) + ")")
+            result += aux + '\n'
         return result
         
     def genus(self):
@@ -289,7 +311,7 @@ class as_cover:
 
     def ith_ramification_gp(self, i, place = 0):
         '''Find ith ramification group at place at infty of nb place.'''
-        G = self.group
+        G = self.group.elts
         t = self.uniformizer(place)
         Gi = [G[0]]
         for g in G:
@@ -302,7 +324,7 @@ class as_cover:
     
     def ramification_jumps(self, place = 0):
         '''Return list of lower ramification jumps at at place at infty of nb place.'''
-        G = self.group
+        G = self.group.elts
         ramification_jps = []
         i = 0
         while len(G) > 1:
diff --git a/as_covers/as_function_class.sage b/as_covers/as_function_class.sage
index a72b3bc..502c5fe 100644
--- a/as_covers/as_function_class.sage
+++ b/as_covers/as_function_class.sage
@@ -3,13 +3,7 @@ class as_function:
         self.curve = C
         F = C.base_ring
         n = C.height
-        variable_names = 'x, y'
-        for i in range(n):
-            variable_names += ', z' + str(i)
-        Rxyz = PolynomialRing(F, n+2, variable_names)
-        x, y = Rxyz.gens()[:2]
-        z = Rxyz.gens()[2:]
-        RxyzQ = FractionField(Rxyz)
+        RxyzQ, Rxyz, x, y, z = C.fct_field
         self.function = RxyzQ(g)
         #self.function = as_reduction(AS, RxyzQ(g))
         
@@ -81,13 +75,7 @@ class as_function:
         y_series = C.y_series[place]
         z_series = C.z_series[place]
         n = C.height
-        variable_names = 'x, y'
-        for j in range(n):
-            variable_names += ', z' + str(j)
-        Rxyz = PolynomialRing(F, n+2, variable_names)
-        x, y = Rxyz.gens()[:2]
-        z = Rxyz.gens()[2:]
-        RxyzQ = FractionField(Rxyz)
+        RxyzQ, Rxyz, x, y, z = C.fct_field
         prec = C.prec
         Rt.<t> = LaurentSeriesRing(F, default_prec=prec)
         g = self.function
@@ -103,13 +91,7 @@ class as_function:
         y_series = C.y_series[pt]
         z_series = C.z_series[pt]
         n = C.height
-        variable_names = 'x, y'
-        for j in range(n):
-            variable_names += ', z' + str(j)
-        Rxyz = PolynomialRing(F, n+2, variable_names)
-        x, y = Rxyz.gens()[:2]
-        z = Rxyz.gens()[2:]
-        RxyzQ = FractionField(Rxyz)
+        RxyzQ, Rxyz, x, y, z = C.fct_field
         prec = C.prec
         Rt.<t> = LaurentSeriesRing(F, default_prec=prec)
         g = self.function
@@ -117,37 +99,39 @@ class as_function:
         sub_list = {x : x_series, y : y_series} | {z[j] : z_series[j] for j in range(n)}
         return g.substitute(sub_list)
 
-    def group_action(self, ZN_tuple):
+    def group_action(self, elt):
         C = self.curve
-        n = C.height
-        F = C.base_ring
-        variable_names = 'x, y'
-        for j in range(n):
-            variable_names += ', z' + str(j)
-        Rxyz = PolynomialRing(F, n+2, variable_names)
-        x, y = Rxyz.gens()[:2]
-        z = Rxyz.gens()[2:]
-        RxyzQ = FractionField(Rxyz)
-        sub_list = {x : x, y : y} | {z[j] : z[j]+ZN_tuple[j] for j in range(n)}
-        g = self.function
-        return as_function(C, g.substitute(sub_list))
+        RxyzQ, Rxyz, x, y, z = C.fct_field
+        Rzf, zgen, fgen = C.cover_template.fct_field
+        if isinstance(elt, group_elt):
+            elt = elt.as_tuple
+        AS = self.curve
+        n = AS.height
+        G = AS.group
+
+        if elt in G.gens:
+            ind = G.gens.index(elt)
+            gp_action_list = C.cover_template.gp_action[ind]
+            sub_list = {x : x, y : y} | {z[j] : Rxyz(gp_action_list[j].subs({zgen[i] : z[i] for i in range(n)})) for j in range(n)}
+            g = self.function
+            return as_function(C, g.substitute(sub_list))
+        result = self
+        for i in range(n):
+            for j in range(elt[i]):
+                result = result.group_action(G.gens[i])
+        return result
+        
 
     def reduce(self):
         aux = as_reduction(self.curve, self.function)
         return as_function(self.curve, aux)
     
-    def trace(self):
+    def trace(self, super=True):
         C = self.curve
         C_super = C.quotient
         n = C.height
         F = C.base_ring
-        variable_names = 'x, y'
-        for j in range(n):
-            variable_names += ', z' + str(j)
-        Rxyz = PolynomialRing(F, n+2, variable_names)
-        x, y = Rxyz.gens()[:2]
-        z = Rxyz.gens()[2:]
-        RxyzQ = FractionField(Rxyz)
+        RxyzQ, Rxyz, x, y, z = C.fct_field
         result = as_function(C, 0)
         G = C.group
         for a in G:
@@ -156,8 +140,11 @@ class as_function:
         Rxy.<x, y> = PolynomialRing(F, 2)
         Qxy = FractionField(Rxy)
         result = as_reduction(C, result)
-        return superelliptic_function(C_super, Qxy(result))
-    
+        if super:
+            return superelliptic_function(C_super, Qxy(result))
+        return as_function(AS, Qxy(result))
+        
+        
     def coordinates(self, prec = 100, basis = 0):
         "Return coordinates in H^1(X, OX)."
         AS = self.curve
@@ -180,14 +167,10 @@ class as_function:
         C_super = C.quotient
         n = C.height
         RxyzQ, Rxyz, x, y, z = C.fct_field
-        fcts = C.functions
         f = self.function
         y_super = superelliptic_function(C_super, y)
         dy_super = y_super.diffn().form
-        dz = []
-        for i in range(n):
-            dfct = fcts[i].diffn().form
-            dz += [-dfct]
+        dz = C.dz
         result = f.derivative(x)
         result += f.derivative(y)*dy_super
         for i in range(n):