diff --git a/ntruencrypt/Makefile b/ntruencrypt/Makefile
new file mode 100644
index 0000000..8e1ec7f
--- /dev/null
+++ b/ntruencrypt/Makefile
@@ -0,0 +1,11 @@
+CC=gcc
+objets= polynome.o queue_pol.o  main.o test.o
+
+all : $(objets)
+	$(CC) -o $@ $^
+
+%.o : %.c
+	gcc -c -Wall $<
+
+clean : 
+	rm -f all *.o
diff --git a/ntruencrypt/all b/ntruencrypt/all
new file mode 100644
index 0000000..2a5f9dd
Binary files /dev/null and b/ntruencrypt/all differ
diff --git a/ntruencrypt/main.c b/ntruencrypt/main.c
new file mode 100644
index 0000000..c758cd0
--- /dev/null
+++ b/ntruencrypt/main.c
@@ -0,0 +1,21 @@
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include "polynome.h"
+#include "test.h"
+
+int main()
+{
+    polynomial_d *t1=empty_pol();
+    t1->p[0]=1;
+    t1->p[1]=-1;
+    degr(t1);
+    print_pol(t1);printf("\n");
+    polynomial_d *test=empty_pol();
+    print_pol(test);
+    lin_comb(empty_pol(),t1->p[t1->deg],t1,test);
+    print_pol(test);printf("\n");
+    test_div_euc_p();
+    
+    return 0;
+}
diff --git a/ntruencrypt/main.o b/ntruencrypt/main.o
new file mode 100644
index 0000000..e1c45a2
Binary files /dev/null and b/ntruencrypt/main.o differ
diff --git a/ntruencrypt/polynome.c b/ntruencrypt/polynome.c
new file mode 100644
index 0000000..1b5fd44
--- /dev/null
+++ b/ntruencrypt/polynome.c
@@ -0,0 +1,459 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include "polynome.h"
+/* Renvoie le polynome nul possedant N coefficients */
+polynomial_d *empty_pol ()
+{
+    polynomial_d *p_d;
+    p_d=malloc(sizeof(polynomial_d));
+    p_d->deg=0;        
+    p_d->p=calloc(N, sizeof (int));
+    return p_d;
+}
+
+/* Remet un polynome à zéro */
+void zero(polynomial_d *u){
+    for(int k=0;k<N;k++){
+        u->p[k]=0;
+    }
+}
+
+/* Renvoie le polynome X^n */
+polynomial_d *X(int n){
+    polynomial_d *p_dxn = empty_pol();
+    p_dxn->p[n]=1;
+    p_dxn->deg=n;
+    return p_dxn;
+}
+
+/* Met le degré du polynome_d u au degré de u */
+void degr(polynomial_d *u){
+    u->deg=N;
+    while((u->p[u->deg]==0)&&(u->deg>=1)){
+        u->deg--;
+    }
+}
+
+/* Affiche le polynome donné en entrée */
+void print_pol(polynomial_d *u){
+    if(u->deg ==0){
+        printf("%d\n",u->p[0]);
+    }
+    else {
+        int first_non_zero=0;
+        while (u->p[first_non_zero]==0){
+            first_non_zero++;
+        }
+        if(first_non_zero==0){
+            printf("%d ",u->p[first_non_zero]);
+        }
+        else if(first_non_zero==u->deg){
+            if(u->p[first_non_zero]==1){
+                printf("X^%d",first_non_zero);
+            }
+            else{
+                printf("%dX^%d",u->p[first_non_zero],first_non_zero);
+            }
+        }
+        else{
+            if(u->p[first_non_zero]==1){
+                printf("X^%d ",first_non_zero);
+            }
+            else{
+                printf("%dX^%d ",u->p[first_non_zero],first_non_zero);
+            }
+        }
+        for (int k=first_non_zero + 1; k<u->deg; k++){
+            if(u->p[k]<0){
+                if(u->p[k]==-1){
+                    printf("- X^%d ",k);
+                }
+                else{
+                    printf("- %dX^%d ",-u->p[k],k);
+                }
+            }
+            else if(u->p[k]>0){
+                if(u->p[k]==1){
+                    printf("+ X^%d ",k);
+                }
+                else{
+                    printf("+ %dX^%d ",u->p[k],k);
+                }
+            }
+        }
+        if(first_non_zero!=u->deg){
+            if(u->p[u->deg]<0){
+                if(u->p[u->deg]==-1){
+                    printf("- X^%d\n",u->deg);
+                }
+                else{
+                    printf("- %dX^%d\n",-u->p[u->deg],u->deg);
+                }
+            }
+            else if(u->p[u->deg]>0){
+                if(u->p[u->deg]==1){
+                    printf("+ X^%d\n",u->deg);
+                }
+                else{
+                    printf("+ %dX^%d\n",u->p[u->deg],u->deg);
+                }
+            }
+        }   
+        else{
+            printf("\n");
+        }
+    }
+}
+
+/* Affiche le polynome donné en entrée dans le fichier out*/
+void print_pol2(FILE *out, polynomial_d *u){
+    if(u->deg ==0){
+        fprintf(out,"%d\n",u->p[0]);
+    }
+    else {
+        int first_non_zero=0;
+        while (u->p[first_non_zero]==0){
+            first_non_zero++;
+        }
+        if(first_non_zero==0){
+            fprintf(out,"%d ",u->p[first_non_zero]);
+        }
+        else if(first_non_zero==u->deg){
+            if(u->p[first_non_zero]==1){
+                fprintf(out,"X^%d",first_non_zero);
+            }
+            else{
+                fprintf(out,"%dX^%d",u->p[first_non_zero],first_non_zero);
+            }
+        }
+        else{
+            if(u->p[first_non_zero]==1){
+                fprintf(out,"X^%d ",first_non_zero);
+            }
+            else{
+                fprintf(out,"%dX^%d ",u->p[first_non_zero],first_non_zero);
+            }
+        }
+        for (int k=first_non_zero + 1; k<u->deg; k++){
+            if(u->p[k]<0){
+                if(u->p[k]==-1){
+                    fprintf(out,"- X^%d ",k);
+                }
+                else{
+                    fprintf(out,"- %dX^%d ",-u->p[k],k);
+                }
+            }
+            else if(u->p[k]>0){
+                if(u->p[k]==1){
+                    fprintf(out,"+ X^%d ",k);
+                }
+                else{
+                    fprintf(out,"+ %dX^%d ",u->p[k],k);
+                }
+            }
+        }
+        if(first_non_zero!=u->deg){
+            if(u->p[u->deg]<0){
+                if(u->p[u->deg]==-1){
+                    fprintf(out,"- X^%d\n",u->deg);
+                }
+                else{
+                    fprintf(out,"- %dX^%d\n",-u->p[u->deg],u->deg);
+                }
+            }
+            else if(u->p[u->deg]>0){
+                if(u->p[u->deg]==1){
+                    fprintf(out,"+ X^%d\n",u->deg);
+                }
+                else{
+                    fprintf(out,"+ %dX^%d\n",u->p[u->deg],u->deg);
+                }
+            }
+        }   
+        else{
+            fprintf(out,"\n");
+        }
+    }
+}
+
+/* print le tableau représentant le polynome u */
+void print_pol_o(polynomial_d *u){
+    printf("[%d;",u->p[0]);
+    for(int k=1;k<N-1;k++){
+        printf("%d;",u->p[k]);
+    }
+    printf("%d]\n",u->p[N-1]);
+    degr(u);
+}
+
+/* Renvoie value à la puissance power */
+int pow_opt(int value, int power){
+    int r=value;
+    for(int k=1;k<power;k++){
+        r=r*value;
+    }
+    return r;
+}
+
+/* Renvoie le polynome f ou ses coefficients sont modulos p ou q */
+void modulo_p (polynomial_d *u, polynomial_d *p_dmp)
+{
+    for (int k = 0; k<=u->deg; k++)
+        {
+            p_dmp->p[k]=u->p[k]%P;
+        }
+        degr(u);
+}
+void modulo_q (polynomial_d *u, polynomial_d *p_dmq)
+{
+  for (int k = 0; k<=u->deg; k++)
+    {
+        p_dmq->p[k]=u->p[k]%Q;
+    }
+    degr(u);
+}
+/* Renvoie un pointeur sur la combinaison linéaire de deux polynômes u et v et d'un entier relatif break
+* Renvoie u+ kv */
+void lin_comb(polynomial_d *u, int l, polynomial_d *v, polynomial_d *p_dcl){
+    for (int k=0; k<=u->deg || k<=v->deg; k++){
+        p_dcl->p[k]= u->p[k] + l*v->p[k];
+    }
+    degr(p_dcl);
+}
+    
+/* Renvoie le produit de convolution de deux polynomes */
+void conv(polynomial_d *u, polynomial_d *v, polynomial_d *p_dc)
+{
+    for (int k=0; k<N; k++)
+    {
+        for (int i=0; i<=k; i++){
+            p_dc->p[k]= p_dc->p[k] + u->p[i]*v->p[k-i];
+        }
+        for (int i=N+k-v->deg; i<=u->deg; i++){
+            p_dc->p[k]= p_dc->p[k] + u->p[i]*v->p[N+k-i];
+            
+        }
+    }
+    degr(p_dc);
+}
+
+/* Renvoie le center lift d'un polynome f 
+ * dont on a donné en argument le polynbome */
+void center_lift(polynomial_d *u, polynomial_d *p_dl){
+    int coef;
+    for(int k=0; k<=u->deg; k++){
+        coef = u->p[k]%Q;
+        if(2*coef>Q){
+            p_dl->p[k] = Q-coef;
+        } 
+        else{
+            p_dl->p[k] = coef;
+        }
+    }
+}
+
+/* fonction auxiliaire de div_euc permettant de remettre le degré de r à son actuel degré, 
+ * car celui ci décroit à chque itération de la boucle while */
+void deg_dec(polynomial_d *u){
+    while((u->p[u->deg]==0)&&(u->deg>=1)){
+        u->deg--;
+    }
+}
+
+/* Fait la division euclidienne de u par v dans R_p
+ * v doit être unitaire
+ * Modifie les arguments r, reste et q, quotient donnée en argument */
+void div_euc_p(polynomial_d *u, polynomial_d *v, polynomial_d *r, polynomial_d *q){
+    r->p=u->p;
+    
+    if(u->deg<v->deg){
+       r->deg=u->deg;
+    }
+    else{
+        degr(r);
+        
+        q->deg=u->deg-v->deg;
+        polynomial_d *p_dc=empty_pol();
+        
+        int v_inv_p = pow_opt(v->p[v->deg],P-1)%P;
+        int i=0;
+        
+        while (r->deg >= v->deg){
+            printf("on est la (%d)\n",i);
+            printf("r :");
+            print_pol(r);
+            
+            printf("q :");
+            print_pol(q);
+            
+            conv(X(r->deg-v->deg), v, p_dc);
+            printf("p_dc :");
+            print_pol(p_dc);
+            printf("\n");
+            
+            q->p[r->deg-v->deg]=r->p[r->deg]*v_inv_p%P;
+            
+            lin_comb(r, -1*r->p[r->deg]*v_inv_p, p_dc, r);
+            zero(p_dc);
+            
+            i++;
+            
+        }
+        free(p_dc);
+    }
+}
+/* Fait la division euclidienne de u par v dans R_q
+ * v doit être unitaire
+ * Modifie les arguments r, reste et q, quotient donnée en argument */
+void div_euc_q(polynomial_d *u, polynomial_d *v, polynomial_d *r, polynomial_d *q){
+    r->p=u->p;
+    
+    if(u->deg<v->deg){
+       r->deg=u->deg;
+    }
+    else{
+        degr(r);
+        
+        q->deg=u->deg-v->deg;
+        polynomial_d *p_dc=empty_pol();
+        
+        int v_inv_q =pow_opt(v->p[v->deg],Q-1)%Q;
+        int i=0;
+        
+        while (r->deg >= v->deg){
+            printf("on est la (%d)\n",i);
+            printf("r :");
+            print_pol(r);
+            
+            printf("q :");
+            print_pol(q);
+            
+            conv(X(r->deg-v->deg), v, p_dc);
+            printf("p_dc :");
+            print_pol(p_dc);
+            printf("\n");
+            
+            q->p[r->deg-v->deg]=r->p[r->deg]*v_inv_q%Q;
+            
+            lin_comb(r, -1*r->p[r->deg]*v_inv_q, p_dc, r);
+            zero(p_dc);
+            
+            i++;
+            
+        }
+        free(p_dc);
+    }
+}
+
+/* Fait la division euclidenne de dom(v)u par v 
+ * v peut donc ne pas être unitaire 
+ * Modifie les arguments r reste et q quotient donnée en argument */
+void div_euc(polynomial_d *u, polynomial_d *v, polynomial_d *r, polynomial_d *q){
+    if(v->p[v->deg]==1){
+        div_euc_q(u,v,r,q);
+    }
+    else{
+        polynomial_d *p_dc=empty_pol();
+        r->deg=u->deg;
+        r->p=u->p;
+        int i=0;
+        while (r->deg >= v->deg){
+            lin_comb(empty_pol(),v->p[v->deg],r,r);
+            printf("on est la(%d)\n",i);
+            printf("r :");
+            print_pol(r);
+            lin_comb(empty_pol(),v->p[v->deg],q,q);
+            printf("q :");
+            print_pol(q);
+            printf("v :");
+            print_pol(v);
+            conv(X(r->deg-v->deg), v, p_dc);
+            printf("p_dc :");
+            print_pol(p_dc);
+            printf("\n");
+            q->p[r->deg-v->deg]=r->p[r->deg]/v->p[v->deg];
+            degr(q);
+            lin_comb(r, -1*(r->p[r->deg]/v->p[v->deg]), p_dc, r);
+            zero(p_dc);
+            i++;
+        }
+        free(p_dc);
+    }
+}
+
+/* Rend unitaire un polynome u */
+void unitaire(polynomial_d *u){
+    for (int k=0;k<=u->deg;k++){
+        u->p[k]=u->p[k]/u->p[u->deg];
+    }
+}
+
+/* Fait le pgcd de u et v 
+ * Modifie les arguments r, reste et q, quotient donnée en argument */
+void pgcd_o(polynomial_d *u, polynomial_d *v, polynomial_d *rn){
+    rn->deg=u->deg;
+    rn->p=u->p;
+    polynomial_d *rn_plus_1;
+    rn_plus_1 = empty_pol();
+    rn_plus_1->deg=v->deg;
+    rn_plus_1->p=v->p;
+    polynomial_d *q=empty_pol();
+    polynomial_d *aux=empty_pol();
+    while((rn_plus_1->deg!=0)||(rn_plus_1->p[0]!=0)){
+        div_euc(rn,rn_plus_1,rn,q);
+        aux->deg=rn->deg;
+        aux->p=rn->p;
+        rn->deg=rn_plus_1->deg;
+        rn->p=rn_plus_1->p;
+        rn_plus_1->deg=aux->deg;
+        rn_plus_1->p=aux->p;
+    }
+    free(rn_plus_1);
+    unitaire(rn);
+}
+/* Fait le pgcd de u et v 
+ * Modifie les arguments r, reste et q, quotient donnée en argument */
+void pgcd(polynomial_d *u, polynomial_d *v, polynomial_d *rn, queue_pol **q_p){
+    rn->deg=u->deg;
+    rn->p=u->p;
+    
+    polynomial_d *rn_plus_1=empty_pol();
+    rn_plus_1->deg=v->deg;
+    rn_plus_1->p=v->p;
+    
+    polynomial_d *qn=empty_pol();
+    polynomial_d *aux=empty_pol();
+    while((rn_plus_1->deg!=0)||(rn_plus_1->p[0]!=0)){
+        queue_post(q_p,qn);
+        div_euc(rn,rn_plus_1,rn,qn);
+        aux->deg=rn->deg;
+        aux->p=rn->p;
+        rn->deg=rn_plus_1->deg;
+        rn->p=rn_plus_1->p;
+        rn_plus_1->deg=aux->deg;
+        rn_plus_1->p=aux->p;
+    }
+    free(rn_plus_1);
+    unitaire(rn);
+}       
+/* Trouve deux suites de polynomes an et bn pour tout n on ait
+ * rn-1=u*an-1 + v*bn-1 
+ * rn=u*an + v*bn
+ * rn-1= qn*rn +rn-1 -> rn+1= qn*(u*an +v*bn) +u*an-1 +v*bn-1
+ * rn+1=u*(qn*an+an-1) + v*(qn*bn+bn-1)
+ * an+1=qn*an +an-1 ; a0=1 et a1=0 
+ * bn+1=qn*bn +bn-1 ; b0=0 et b1=1 
+ * Il s'agit donc d'avoir la suite de polynome (qn)
+ */ 
+void bezout(polynomial_d *u, polynomial_d *v, polynomial_d *rn, polynomial_d *an, polynomial_d *bn, queue_pol *q_p){
+    pgcd(u,v,rn,&q_p);}
+    
+        
+/* Renvoie l'inverse d'un polynome f dans l'anneau F_p ou F_q 
+polynomial *inv_p (polynomial f){
+    p111 An intro to matghematical gngn
+    p402
+}
+polynomial *inv_q (polynomial f);
+*/
diff --git a/ntruencrypt/polynome.h b/ntruencrypt/polynome.h
new file mode 100644
index 0000000..3f694ce
--- /dev/null
+++ b/ntruencrypt/polynome.h
@@ -0,0 +1,101 @@
+#ifndef POLYNOME_H
+#define POLYNOME_H
+
+
+/* on choisit le triplet public (N,p,q) au debut du programme 
+* TOUS les polynomes seront de degré N-1 */
+#define N 11
+#define P 7
+#define Q 2
+/* les polynomes seront donc representés par des tableaux de taille N  */
+typedef int * polynomial;
+
+struct polynomial_s{
+    polynomial p;
+    int deg;
+};
+typedef struct polynomial_s polynomial_d;
+
+struct queue_pol_s
+{
+   struct queue_pol_s *prev;
+   struct queue_pol_s *next;
+   polynomial_d *p_d;
+};
+
+typedef struct queue_pol_s queue_pol;
+#include "queue_pol.h"
+/* print le polynome sous sa forme mathematique */
+void print_pol(polynomial_d *u);
+/* print le tableau représentant le polynome u */
+void print_pol_o(polynomial_d *u);
+
+/* print le polynome sous sa forme mathematique dans le fichier texte out*/
+void print_pol2(FILE *out, polynomial_d *u);
+
+/* Renvoie le polynôme nul possèdant N coefficient */
+polynomial_d *empty_pol();
+
+/* Remet à zero un polynome */
+void zero(polynomial_d *u);
+
+/* Renvoie le polynome X^n */
+polynomial_d *X(int n);
+
+/* Met le degré du polynome_d u au degré de u */
+void degr(polynomial_d *u);
+
+/* Renvoie value à la puissance power */
+int pow_opt(int value, int power);
+
+/* Renvoie un pointeur sur le polynôme f où ses coefficients sont modulos n, où n=p ou n=q */
+void modulo_p(polynomial_d *u, polynomial_d *p_dmp);
+void modulo_q(polynomial_d *u, polynomial_d *p_dmq);
+
+/* Renvoie un pointeur sur le polynôme f modulo X^N-1 
+* où N est le paramètre que l'on se donne au début du chiffrement */
+void modulo_N(polynomial_d *u, polynomial_d *p_dmN);
+
+/* Renvoie un pointeur sur la combinaison linéaire de deux polynômes u et v et d'un entier relatif break
+* Renvoie u+ kv */
+void lin_comb(polynomial_d *u, int k, polynomial_d *v, polynomial_d *p_dcl);
+
+/* Renvoie un pointeur sur le produit de convolution de deux polynômes */
+void conv(polynomial_d *u, polynomial_d *v, polynomial_d *p_dc);
+
+/* Renvoie le center lift du polynome f */
+void center_lift(polynomial_d *u, polynomial_d *p_dl);
+
+/* Renvoie un pointeur sur l'inverse d'un polynôme f dans l'anneau F_n, où n=p ou n=q */
+void inv(polynomial_d *u, int n);
+
+/* fonction auxiliaire de div_euc permettant de remettre le degré de r à son actuel degré, 
+ * car celui ci décroit à chque itération de la boucle while */
+void deg_dec(polynomial_d *u);
+/* Fait la division euclidienne de u par v dans R_p
+ * v doit être unitaire
+ * Modifie les arguments r, reste et q, quotient donnée en argument */
+void div_euc_p(polynomial_d *u, polynomial_d *v, polynomial_d *r, polynomial_d *q);
+/* Fait la division euclidienne de u par v dans R_q
+ * v doit être unitaire
+ * Modifie les arguments r, reste et q, quotient donnée en argument */
+void div_euc_q(polynomial_d *u, polynomial_d *v, polynomial_d *r, polynomial_d *q);
+/*Modifie les arguments r, reste et q, quotient donnée en argument */
+void div_euc(polynomial_d *u, polynomial_d *v, polynomial_d *r, polynomial_d *q);
+
+/* Rend unitaire un polynome u */
+void unitaire(polynomial_d *u);
+/* Fait le pgcd de u et v 
+ * Modifie les arguments r, reste et q, quotient donnée en argument */
+void pgcd_o(polynomial_d *u, polynomial_d *v, polynomial_d *rn);
+ /* Fait le pgcd de u et v 
+ * Modifie les arguments r, reste et q, quotient donnée en argument */
+void pgcd(polynomial_d *u, polynomial_d *v, polynomial_d *rn, queue_pol **q_p);
+/* Fait le pgcd de u et v 
+ * Modifie les arguments r, reste et q, quotient donnée en argument */
+void bezou(polynomial_d *u, polynomial_d *v, polynomial_d *rn, polynomial_d *an, polynomial_d *bn, queue_pol* q_p);
+
+polynomial_d *inv_q(polynomial);
+polynomial_d *inv_p(polynomial);
+
+#endif
diff --git a/ntruencrypt/polynome.o b/ntruencrypt/polynome.o
new file mode 100644
index 0000000..a3f8ea9
Binary files /dev/null and b/ntruencrypt/polynome.o differ
diff --git a/ntruencrypt/queue_pol.c b/ntruencrypt/queue_pol.c
new file mode 100644
index 0000000..e12920a
--- /dev/null
+++ b/ntruencrypt/queue_pol.c
@@ -0,0 +1,109 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "queue_pol.h"
+#include "polynome.h"
+static void queue_first (queue_pol**);
+static void queue_prev (queue_pol**);
+static void queue_last (queue_pol**);
+static void queue_next (queue_pol**);
+
+queue_pol*queue_new (void)
+{
+   return (NULL);
+}
+
+void queue_post (queue_pol** pp_queue, polynomial_d *p_d)
+{
+   if (pp_queue != NULL)
+   {
+      queue_pol*p_l = NULL;
+      queue_pol*p_p = NULL;
+
+      queue_first (pp_queue);
+      p_l = *pp_queue;
+      p_p = malloc (sizeof (*p_p));
+      if (p_p != NULL)
+      {
+         p_p->p_d = p_d;
+         p_p->next = p_l;
+         p_p->prev = NULL;
+         if (p_l != NULL)
+            p_l->prev = p_p;
+         *pp_queue = p_p;
+      }     
+      else
+      {
+         fprintf (stderr, "Memoire insuffisante\n");
+         exit (EXIT_FAILURE);
+      }
+   }
+   return;
+}
+
+void queue_get (queue_pol** pp_queue, polynomial_d *p_d)
+{
+   if (pp_queue != NULL && *pp_queue != NULL)
+   {
+      queue_pol*p_l = NULL;
+      queue_pol*p_p = NULL;
+      
+      queue_last (pp_queue);
+      p_l = *pp_queue;
+      if (p_l != NULL)
+         p_p = p_l->prev;
+      p_d->deg = p_l->p_d->deg;
+      p_d->p = p_l->p_d->p;
+      free (p_l);
+      p_l = NULL;
+      if (p_p != NULL)
+         p_p->next = NULL;
+      *pp_queue = p_p;
+   }
+}
+
+void queue_delete (queue_pol** pp_queue)
+{
+    polynomial_d *p_dd=empty_pol();
+   if (pp_queue != NULL && *pp_queue != NULL)
+   {
+      while (*pp_queue != NULL){
+          queue_get (pp_queue,p_dd);
+          free(p_dd);
+      }
+   }
+   return;
+}
+
+static void queue_first (queue_pol** pp_queue)
+{
+   if (pp_queue != NULL && *pp_queue != NULL)
+   {
+      while ((*pp_queue)->prev != NULL)
+         queue_prev (pp_queue);
+   }
+   return;
+}
+
+static void queue_prev (queue_pol** pp_queue)
+{
+   if (pp_queue != NULL && *pp_queue != NULL)
+      *pp_queue = (*pp_queue)->prev;
+   return;
+}
+
+static void queue_last (queue_pol** pp_queue)
+{
+   if (pp_queue != NULL && *pp_queue != NULL)
+   {
+      while ((*pp_queue)->next != NULL)
+         queue_next (pp_queue);
+   }
+   return;
+}
+
+static void queue_next (queue_pol** pp_queue)
+{
+   if (pp_queue != NULL && *pp_queue != NULL)
+      *pp_queue = (*pp_queue)->next;
+   return;
+}
diff --git a/ntruencrypt/queue_pol.h b/ntruencrypt/queue_pol.h
new file mode 100644
index 0000000..7456ad7
--- /dev/null
+++ b/ntruencrypt/queue_pol.h
@@ -0,0 +1,12 @@
+#ifndef QUEUE_POL_H
+#define QUEUE_POL_H
+
+#include "polynome.h"
+
+
+queue_pol *queue_new (void);
+void queue_post (queue_pol **, polynomial_d *);
+void queue_get (queue_pol **, polynomial_d *);
+void queue_delete (queue_pol **);
+
+#endif 
diff --git a/ntruencrypt/queue_pol.o b/ntruencrypt/queue_pol.o
new file mode 100644
index 0000000..bca5f15
Binary files /dev/null and b/ntruencrypt/queue_pol.o differ
diff --git a/ntruencrypt/test.c b/ntruencrypt/test.c
new file mode 100644
index 0000000..c6b1c68
--- /dev/null
+++ b/ntruencrypt/test.c
@@ -0,0 +1,185 @@
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include "test.h"
+#include "queue_pol.h"
+
+/* Initialise le polynome u à la valeur souhaité par l'utilisateur */
+void def_pol(polynomial_d *u){
+    int coef,val_coef;
+    int is_well_def=0;
+    while (is_well_def==0){
+        int go_on_def_pol=1;
+        while(go_on_def_pol==1){
+            printf("X^");
+            scanf("%d",&coef);
+            scanf("%d",&val_coef);
+            printf("go_on_def_pol OUI(1) NON(0) :");
+            scanf("%d",&go_on_def_pol);
+            printf("\n");
+            u->p[coef]=val_coef;
+        }
+        degr(u);
+        print_pol(u);
+        /* print_pol_o(u);*/
+        printf("Est-ce le bon polynome ? OUI(1) NON(0) ");
+        scanf("%d",&is_well_def);
+        printf("\n");
+    }
+}
+
+/* Crée autant de polynomes u et v que l'utilisateur souhaite 
+ * puis test div_euc(u,v,r,q) r et q ayant déjà été initialisés à empty_pol()*/
+void test_div_euc_p_o(void){
+    int go_on=1;
+    
+    polynomial_d *u=empty_pol();
+    polynomial_d *v=empty_pol();
+    polynomial_d *r=empty_pol();
+    polynomial_d *q=empty_pol();
+    while(go_on==1){
+        printf("/* begin div_eucl test */\n");
+        printf("Initialisation de u :\n");
+        def_pol(u);
+        print_pol(u);
+        printf("deg u :%d\n",u->deg);
+        printf("Initialisation de v :\n");
+        def_pol(v); 
+        print_pol(v);
+        printf("deg v :%d",v->deg);
+        div_euc(u,v,r,q);
+        printf("r : ");
+        print_pol(r);
+        printf("q : ");
+        print_pol(q);
+        printf("/* end div_eucl test */\n\n");
+        printf("go_on OUI(1) NON(0) :");
+        scanf("%d",&go_on);
+        printf("\n");
+    }
+    free(u);
+    free(v);
+    free(r);
+    free(q);
+}
+
+/* Initialise le polynome u à la valeur souhaité par l'utilisateur */
+void get_pol(FILE *in, polynomial_d *u){
+    int coef,val_coef;
+    
+    while(getc(in)!='\n'){
+        fscanf(in,"%d %d",&coef,&val_coef);
+        u->p[coef]=val_coef;
+    }
+    degr(u);
+}
+
+/* Crée autant de polynomes u et v que l'utilisateur souhaite 
+ * puis test div_euc(u,v,r,q) r et q ayant déjà été initialisés à empty_pol()*/
+void test_div_euc_p(void){
+    FILE *in = fopen("test_div_euc_p.txt","r");
+    
+    if (in == NULL)
+    {
+        printf("Cannot open the source file.\n");
+        exit(1);
+    }
+    
+    char ch;
+    
+    polynomial_d *u = empty_pol();
+    polynomial_d *v = empty_pol();
+    polynomial_d *r = empty_pol();
+    polynomial_d *q = empty_pol();
+    
+    while(!feof(in)){
+        printf("/* begin div_eucl test */\n");
+        
+        printf("u :");
+        get_pol(in,u);
+        print_pol(u);
+        printf("deg u :%d\n",u->deg);
+        
+        printf("v :");
+        get_pol(in,v); 
+        print_pol(v);
+        printf("deg v :%d\n\n",v->deg);
+        
+        div_euc_p(u,v,r,q);
+        printf("r : ");
+        print_pol(r);
+        
+        printf("q : ");
+        print_pol(q);
+    
+        printf("/* end div_eucl test */\n\n");
+        
+        ch = getc(in);
+    }
+    free(u);
+    free(v);
+    free(r);
+    free(q);
+}
+
+/* Crée autant de polynomes u et v que l'utilisateur souhaite 
+ * puis test pgcd(u,v,r,q) r et q ayant déjà été initialisés à empty_pol() */
+void test_pgcd_o(void){
+    int go_on=1;
+    polynomial_d *u=empty_pol();
+    polynomial_d *v=empty_pol();
+    polynomial_d *rn=empty_pol();
+    while(go_on==1){
+        printf("/* begin pgcd test */\n");
+        printf("Initialisation de u :\n");
+        def_pol(u);
+        print_pol(u);
+        printf("deg u :%d\n\n",u->deg);
+        printf("Initialisation de v :\n");
+        def_pol(v); 
+        print_pol(v);
+        printf("deg v :%d\n\n",v->deg);
+        pgcd_o(u,v,rn);
+        printf("rn : ");
+        print_pol(rn);
+        printf("/* end pgcd test */\n\n");
+        printf("go_on OUI(1) NON(0) :");
+        scanf("%d",&go_on);
+        printf("\n");
+    }
+    free(u);
+    free(v);
+    free(rn);
+}
+
+/* Crée autant de polynomes u et v que l'utilisateur souhaite 
+ * puis test pgcd(u,v,r,q) r et q ayant déjà été initialisés à empty_pol()*/
+void test_pgcd(void){
+    int go_on=1;
+    queue_pol *q_p;
+    q_p=queue_new();
+    polynomial_d *u=empty_pol();
+    polynomial_d *v=empty_pol();
+    polynomial_d *rn=empty_pol();
+    while(go_on==1){
+        printf("/* begin pgcd test */\n");
+        printf("Initialisation de u :\n");
+        def_pol(u);
+        print_pol(u);
+        printf("deg u :%d\n\n",u->deg);
+        printf("Initialisation de v :\n");
+        def_pol(v); 
+        print_pol(v);
+        printf("deg v :%d\n\n",v->deg);
+        pgcd(u,v,rn,&q_p);
+        printf("rn : ");
+        print_pol(rn);
+        printf("/* end pgcd test */\n\n");
+        printf("go_on OUI(1) NON(0) :");
+        scanf("%d",&go_on);
+        printf("\n");
+    }
+    free(u);
+    free(v);
+    free(rn);
+}
diff --git a/ntruencrypt/test.h b/ntruencrypt/test.h
new file mode 100644
index 0000000..3adee4f
--- /dev/null
+++ b/ntruencrypt/test.h
@@ -0,0 +1,25 @@
+#ifndef TEST_H
+#define TEST_H
+#include "polynome.h"
+/* Initialise le polynome u à la valeur souhaité par l'utilisateur */
+void def_pol(polynomial_d *u);
+
+/* Crée autant de polynomes u et v que l'utilisateur souhaite 
+ * puis test div_euc(u,v,r,q) r et q ayant déjà été initialisés à empty_pol()*/ 
+void test_div_euc_p_o(void);
+
+/* Initialise le polynome u à la valeur souhaité par l'utilisateur */
+void get_pol(FILE *in, polynomial_d *u);
+
+/* Crée autant de polynomes u et v que l'utilisateur souhaite 
+ * puis test div_euc(u,v,r,q) r et q ayant déjà été initialisés à empty_pol()*/
+void test_div_euc_p(void);
+
+/* Crée autant de polynomes u et v que l'utilisateur souhaite 
+ * puis test pgcd(u,v,r,q) r et q ayant déjà été initialisés à empty_pol()*/
+void test_pgcd(void);
+
+#endif
+
+
+    
diff --git a/ntruencrypt/test.o b/ntruencrypt/test.o
new file mode 100644
index 0000000..2472167
Binary files /dev/null and b/ntruencrypt/test.o differ
diff --git a/ntruencrypt/test2.c b/ntruencrypt/test2.c
new file mode 100644
index 0000000..ed94d00
--- /dev/null
+++ b/ntruencrypt/test2.c
@@ -0,0 +1,100 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "test2.h"
+
+/* Initialise le polynome u à la valeur souhaité par l'utilisateur */
+void get_pol(FILE *in, polynomial_d *u){
+    int coef,val_coef;
+    
+    while(getc(in)!='\n'){
+        fscanf("%d %d",&coef,&val_coef);
+        u->p[coef]=val_coef;
+    }
+    degr(u);
+    
+    printf("\n");
+}
+
+void test_div_euc_p()
+{
+    FILE *in, *out;
+ 
+    in = fopen("test_div_euc_o _p.txt", "r");
+    if (in == NULL)
+    {
+        printf("Cannot open the source file.\n");
+        exit(1);
+    }
+ 
+    out = fopen("result_div_euc_o_p.txt", "w");
+    if (out == NULL)
+    {
+        printf("Cannot open the destination file.\n");
+        exit(1);
+    }
+ 
+    char ch;
+ 
+    // faire jusqu'à ce que la fin du fichier soit atteinte
+    while (!feof(in))
+    {
+        // lit la prochaine paire d'entrées du fichier
+        get_pol(in,u);
+        get_pol(in,v);
+ 
+        // calcule pgcd et imprime dans le fichier de sortie
+        print_pol2(out,r);
+        print_pol2(out,q);
+ 
+        // passe à la ligne suivante
+        ch = getc(in);
+    }
+ 
+    // ferme le flux de fichiers d'entrée et de sortie
+    fclose(out);
+    fclose(in);
+}
+
+void test_div_euc_q()
+{
+    FILE *in, *out;
+ 
+    in = fopen("test_div_euc_o_q.txt", "r");
+    if (in == NULL)
+    {
+        printf("Cannot open the source file.\n");
+        exit(1);
+    }
+ 
+    out = fopen("result_div_euc_o_q.txt", "w");
+    if (out == NULL)
+    {
+        printf("Cannot open the destination file.\n");
+        exit(1);
+    }
+ 
+    char ch;
+ 
+    // faire jusqu'à ce que la fin du fichier soit atteinte
+    while (!feof(in))
+    {
+        // lit la prochaine paire d'entrées du fichier
+        get_pol(in,u,v);
+        
+        // calcule r et q et imprime dans le fichier de sortie
+        polynomial_d *r=empty_pol();
+        polynomial_d *q=empty_pol();
+        
+        div_euc_o_q(u,v,r,q);
+        print_pol2(out,r,q);
+ 
+        // passe à la ligne suivante
+        ch = getc(in);
+    }
+ 
+    // ferme le flux de fichiers d'entrée et de sortie
+    fclose(out);
+    fclose(in);
+ 
+    return 0;
+}
diff --git a/ntruencrypt/test2.h b/ntruencrypt/test2.h
new file mode 100644
index 0000000..fcc7af8
--- /dev/null
+++ b/ntruencrypt/test2.h
@@ -0,0 +1,6 @@
+#ifndef TEST2_H
+#define TEST2_H     
+
+    void get_pol(FILE *in, polynomial_d *u, polynomial *v);
+
+#endif
diff --git a/ntruencrypt/test_div_euc_p.txt b/ntruencrypt/test_div_euc_p.txt
new file mode 100644
index 0000000..cae5d9a
--- /dev/null
+++ b/ntruencrypt/test_div_euc_p.txt
@@ -0,0 +1,5 @@
+ 0 1 1 1 3 1
+ 0 1 1 1
+
+
+