OneRoundIoT/OneRound/one_round_new.cpp

   1 //gcc pixmap_io.c  -c
   2 //g++ -O3 one_round_new.cpp pixmap_io.o  -o one_round_new -std=c++11
   3
   4 #include <iostream>
   5 #include <list>
   6 #include<math.h>
   7 #include<stdlib.h>
   8 #include<stdio.h>
   9 #include<string.h>
  10 #include <fstream>
  11 #include <sys/time.h>
  12 #include <glib.h>
  13
  14
  15 /*#include <cryptopp/hex.h>
  16 #include <cryptopp/sha.h>
  17 #include <cryptopp/osrng.h>
  18 #include <cryptopp/secblock.h>
  19 */
  20
  21
  22 extern "C" {
  23   int load_RGB_pixmap(char *filename, int *width, int *height, unsigned char**R_data, unsigned char**G_data, unsigned char**B_data);
  24   void store_RGB_pixmap(char *filename, unsigned char *R_data, unsigned char *G_data, unsigned char *B_data, int width, int height);
  25 }
  26
  27
  28 //using namespace CryptoPP;
  29 using namespace std;
  30
  31
  32 int key_size=256;
  33 int nb_test=1;
  34 int ctr=0;
  35
  36
  37
  38
  39
  40
  41
  42 typedef unsigned char   uchar;
  43
  44
  45 double TimeStart()
  46 {
  47   struct timeval tstart;
  48   gettimeofday(&tstart,0);
  49   return( (double) (tstart.tv_sec + tstart.tv_usec*1e-6) );
  50 }
  51
  52 double TimeStop(double t)
  53 {
  54   struct timeval tend;
  55
  56   gettimeofday(&tend,0);
  57   t = (double) (tend.tv_sec + tend.tv_usec*1e-6) - t;
  58   return (t);
  59 }
  60
  61
  62
  63
  64 uint xorshift32(const uint t)
  65 {
  66   /* Algorithm "xor" from p. 4 of Marsaglia, "Xorshift RNGs" */
  67   uint x = t;
  68   x ^= x << 13;
  69   x ^= x >> 17;
  70   x ^= x << 5;
  71   return x;
  72 }
  73
  74
  75
  76 void inverse_tables(uchar *tab, int size_tab,uchar *inv_perm_tabs) {
  77
  78   for(int i=0;i<size_tab;i++) {
  79     inv_perm_tabs[tab[i]] = i;
  80   }
  81
  82 }
  83
  84 void inverse_tables_int(int *tab, int size_tab,int *inv_perm_tabs) {
  85
  86   for(int i=0;i<size_tab;i++) {
  87     inv_perm_tabs[tab[i]] = i;
  88   }
  89
  90 }
  91
  92
  93
  94 void rc4key(uchar *key, uchar *sc, int size_DK) {
  95
  96   for(int i=0;i<256;i++) {
  97     sc[i]=i;
  98   }
  99
 100
 101   uchar j0 = 0;
 102   for(int i0=0; i0<256; i0++) {
 103     j0 = (j0 + sc[i0] + key[i0%size_DK] )&0xFF;
 104     uchar tmp = sc[i0];
 105     sc[i0] = sc[j0 ];
 106     sc[j0] = tmp;
 107   }
 108 }
 109
 110
 111
 112 void rc4keyperm(uchar *key,int len, int rp,int *sc, int size_DK) {
 113
 114   //sc=1:len;
 115
 116
 117
 118   for (int i=0;i<len;i++) {
 119     sc[i]=i;
 120   }
 121   for (int it = 0; it < rp; it++) {
 122     int j0 = 1;
 123     for(int i0 = 0; i0<len; i0++) {
 124       j0 = (j0 + sc[i0] + sc[j0] + key[i0%size_DK] )% len;
 125       int tmp = sc[i0];
 126       sc[i0] = sc[j0];
 127       sc[j0] = tmp;
 128     }
 129
 130   }
 131 }
 132
 133 void prga(uchar *sc, int ldata, uchar *r) {
 134   uchar i0=0;
 135   uchar j0=0;
 136
 137   for (int it=0; it<ldata; it++) {
 138     i0 = ((i0+1)&0xFE); //%255);
 139     j0 = (j0 + sc[i0])&0xFF;
 140     uchar tmp = sc[i0];
 141     sc[i0] = sc[j0];
 142     sc[j0] = tmp;
 143     r[it]=sc[(sc[i0]+sc[j0])&0xFF];
 144   }
 145 }
 146
 147
 148
 149
 150
 151 template<int h2>
 152 void encrypt_ctr(uchar* seq_in, uchar *seq_out, int len,uchar* RM1,int *Pbox, int *PboxRM, uchar *Sbox1, uchar *Sbox2, uint myrand,int enc) {
 153
 154
 155   uchar X[h2];
 156   uchar fX[h2];
 157
 158   int ind1,ind2;
 159
 160
 161
 162   for(int a=0;a<h2;a+=4) {
 163     X[a]=Sbox1[a&0xFF];           //Warning according to the size of h2, we can be outsize of Sbox1[a]
 164     X[a+1]=Sbox1[(a+1)&0xFF];
 165     X[a+2]=Sbox1[(a+2)&0xFF];
 166     X[a+3]=Sbox1[(a+3)&0xFF];
 167   }
 168
 169
 170   for(int it=0;it<len;it++) {
 171     if(enc) {
 172       ind1=it*h2;
 173       ind2=Pbox[it]*h2;
 174     }
 175     else {
 176       ind2=it*h2;
 177       ind1=Pbox[it]*h2;
 178     }
 179
 180
 181     for(int a=0;a<h2;a+=4) {
 182
 183       myrand=xorshift32(myrand);
 184       uint mm=myrand;
 185
 186       X[a]=X[a]^(mm&255);
 187       mm>>=8;
 188       X[a+1]=X[a+1]^(mm&255);
 189       mm>>=8;
 190       X[a+2]=X[a+2]^(mm&255);
 191       mm>>=8;
 192       X[a+3]=X[a+3]^(mm&255);
 193     }
 194
 195
 196
 197
 198
 199     for(int a=0;a<h2;a+=4) {
 200       X[a]=Sbox1[X[a]];
 201       X[a+1]=Sbox1[X[a+1]];
 202       X[a+2]=Sbox1[X[a+2]];
 203       X[a+3]=Sbox1[X[a+3]];
 204     }
 205
 206     for(int a=0;a<h2;a+=4) {
 207       X[a]=X[a]^RM1[a];
 208       X[a+1]=X[a+1]^RM1[a+1];
 209       X[a+2]=X[a+2]^RM1[a+2];
 210       X[a+3]=X[a+3]^RM1[a+3];
 211     }
 212
 213     for(int a=0;a<h2;a+=4) {
 214       fX[a]=X[a]^seq_in[ind2+a];
 215       fX[a+1]=X[a+1]^seq_in[ind2+a+1];
 216       fX[a+2]=X[a+2]^seq_in[ind2+a+2];
 217       fX[a+3]=X[a+3]^seq_in[ind2+a+3];
 218
 219     }
 220
 221
 222     for(int a=0;a<h2;a+=4) {
 223       seq_out[ind1+a]=fX[a];
 224       seq_out[ind1+a+1]=fX[a+1];
 225       seq_out[ind1+a+2]=fX[a+2];
 226       seq_out[ind1+a+3]=fX[a+3];
 227     }
 228
 229     for(int a=0;a<h2;a+=4) {
 230       RM1[a]=RM1[PboxRM[a]];
 231       RM1[a+1]=RM1[PboxRM[a+1]];
 232       RM1[a+2]=RM1[PboxRM[a+2]];
 233       RM1[a+3]=RM1[PboxRM[a+3]];
 234     }
 235
 236
 237
 238   }
 239
 240
 241 }
 242
 243
 244 template<int h2>
 245 void encrypt(uchar* seq_in, uchar *seq_out, int len,uchar* RM1, int *Pbox, int *PboxRM, uchar *Sbox1, uchar *Sbox2, uint myrand, int debug) {
 246
 247   uchar X[h2];
 248   uchar fX[h2];
 249
 250
 251   for(int it=0;it<len;it++) {
 252     int ind1=it*h2;
 253     int ind2=Pbox[it]*h2;
 254
 255     for(int a=0;a<h2;a+=4) {
 256       myrand=xorshift32(myrand);
 257
 258       uint mm=myrand;
 259       X[a]=seq_in[ind2+a]^(mm&255);
 260       mm>>=8;
 261       X[a+1]=seq_in[ind2+a+1]^(mm&255);
 262       mm>>=8;
 263       X[a+2]=seq_in[ind2+a+2]^(mm&255);
 264       mm>>=8;
 265       X[a+3]=seq_in[ind2+a+3]^(mm&255);
 266     }
 267
 268     for(int a=0;a<h2;a+=4){
 269       fX[a]=Sbox1[X[a]];
 270       fX[a+1]=Sbox1[X[a+1]];
 271       fX[a+2]=Sbox1[X[a+2]];
 272       fX[a+3]=Sbox1[X[a+3]];
 273     }
 274
 275
 276     for(int a=0;a<h2;a+=4) {
 277       fX[a]=fX[a]^RM1[a];
 278       fX[a+1]=fX[a+1]^RM1[a+1];
 279       fX[a+2]=fX[a+2]^RM1[a+2];
 280       fX[a+3]=fX[a+3]^RM1[a+3];
 281     }
 282
 283
 284     for(int a=0;a<h2;a+=4) {
 285       seq_out[ind1+a]=Sbox2[fX[a]];
 286       seq_out[ind1+a+1]=Sbox2[fX[a+1]];
 287       seq_out[ind1+a+2]=Sbox2[fX[a+2]];
 288       seq_out[ind1+a+3]=Sbox2[fX[a+3]];
 289     }
 290
 291     for(int a=0;a<h2;a+=4) {
 292       RM1[a]=RM1[PboxRM[a]];
 293       RM1[a+1]=RM1[PboxRM[a+1]];
 294       RM1[a+2]=RM1[PboxRM[a+2]];
 295       RM1[a+3]=RM1[PboxRM[a+3]];
 296
 297     }
 298
 299
 300   }
 301
 302
 303
 304
 305
 306
 307 }
 308
 309
 310
 311
 312
 313
 314
 315
 316 template<int h2>
 317 void decrypt(uchar* seq_in, uchar *seq_out, int len, uchar* RM1, int *Pbox, int *PboxRM, uchar *Inv_Sbox1, uchar *Inv_Sbox2,  uint myrand, int debug) {
 318
 319
 320
 321  uchar fX[h2];
 322
 323
 324
 325   for(int it=0;it<len;it++) {
 326
 327     int ind1=it*h2;
 328     int ind2=Pbox[it]*h2;
 329
 330
 331
 332
 333     for(int a=0;a<h2;a+=4) {
 334       fX[a]=seq_in[ind1+a];
 335       fX[a+1]=seq_in[ind1+a+1];
 336       fX[a+2]=seq_in[ind1+a+2];
 337       fX[a+3]=seq_in[ind1+a+3];
 338
 339     }
 340     for(int a=0;a<h2;a+=4) {
 341       fX[a]=Inv_Sbox2[fX[a]];
 342       fX[a+1]=Inv_Sbox2[fX[a+1]];
 343       fX[a+2]=Inv_Sbox2[fX[a+2]];
 344       fX[a+3]=Inv_Sbox2[fX[a+3]];
 345     }
 346     for(int a=0;a<h2;a+=4) {
 347       fX[a]=fX[a]^RM1[a];
 348       fX[a+1]=fX[a+1]^RM1[a+1];
 349       fX[a+2]=fX[a+2]^RM1[a+2];
 350       fX[a+3]=fX[a+3]^RM1[a+3];
 351     }
 352
 353     for(int a=0;a<h2;a+=4) {
 354       RM1[a]=RM1[PboxRM[a]];
 355       RM1[a+1]=RM1[PboxRM[a+1]];
 356       RM1[a+2]=RM1[PboxRM[a+2]];
 357       RM1[a+3]=RM1[PboxRM[a+3]];
 358     }
 359
 360     for(int a=0;a<h2;a+=4) {
 361       myrand=xorshift32(myrand);
 362
 363       uint mm=myrand;
 364       seq_out[ind2+a]=Inv_Sbox1[fX[a]]^(mm&255);
 365       mm>>=8;
 366       seq_out[ind2+a+1]=Inv_Sbox1[fX[a+1]]^(mm&255);
 367       mm>>=8;
 368       seq_out[ind2+a+2]=Inv_Sbox1[fX[a+2]]^(mm&255);
 369       mm>>=8;
 370       seq_out[ind2+a+3]=Inv_Sbox1[fX[a+3]]^(mm&255);
 371     }
 372
 373
 374   }
 375
 376
 377
 378 }
 379
 380
 381 int main(int argc, char** argv) {
 382
 383
 384   int h=32;
 385   int lena=0;
 386   int size_buf=1;
 387
 388
 389
 390   for(int i=1; i<argc; i++){
 391     if(strncmp(argv[i],"nb",2)==0)    nb_test = atoi(&(argv[i][2]));    //nb of test
 392     if(strncmp(argv[i],"ctr",3)==0) ctr = atoi(&(argv[i][3]));          //CTR ? 1  otherwise CBC like
 393     if(strncmp(argv[i],"h",1)==0) h = atoi(&(argv[i][1]));          //size of block
 394     if(strncmp(argv[i],"sizebuf",7)==0) size_buf = atoi(&(argv[i][7]));          //SIZE of the buffer
 395     if(strncmp(argv[i],"lena",4)==0) lena = atoi(&(argv[i][4]));          //Use Lena or buffer
 396   }
 397
 398 /*  printf("nb times %d\n",nb_test);
 399   printf("ctr %d\n",ctr);
 400   printf("h %d\n",h);
 401   printf("lena %d\n",lena);
 402   printf("size_buf %d\n",size_buf);
 403 */
 404   int h2=h*h;
 405
 406
 407
 408   int seed=time(NULL);
 409 //  cout<<seed<<endl;
 410   srand48(seed);
 411
 412   uchar Secretkey[key_size];
 413
 414   uchar counter[key_size];
 415
 416   for(int i=0;i<key_size;i++) {
 417     Secretkey[i]=lrand48()&0xFF;
 418     counter[i]=lrand48()&0xFF;
 419   }
 420
 421
 422   int size = 64;
 423   uchar DK[size];
 424
 425
 426
 427
 428   int width;
 429   int height;
 430
 431   uchar *data_R, *data_G, *data_B;
 432   int imsize;
 433   uchar *buffer;
 434
 435
 436
 437
 438
 439   if(lena==1) {
 440     load_RGB_pixmap("lena.ppm", &width, &height, &data_R, &data_G, &data_B);
 441 //    load_RGB_pixmap("8192.ppm", &width, &height, &data_R, &data_G, &data_B);
 442     imsize=width*height*3;
 443 //  load_RGB_pixmap("No_ecb_mode_picture.ppm", &width, &height, &data_R, &data_G, &data_B);
 444   }
 445   else {
 446     width=height=size_buf;
 447     imsize=width*height;
 448     buffer=new uchar[imsize];
 449     for(int i=0;i<imsize;i++) {
 450       buffer[i]=lrand48();
 451     }
 452   }
 453
 454
 455
 456
 457
 458   uchar* seq= new uchar[imsize];
 459   uchar* seq2= new uchar[imsize];
 460
 461   int oneD=width*height;
 462   if(lena) {
 463     for(int i=0;i<oneD;i++) {
 464       seq[i]=data_R[i];
 465       seq[oneD+i]=data_G[i];
 466       seq[2*oneD+i]=data_B[i];
 467     }
 468   }
 469   else {
 470     for(int i=0;i<oneD;i++) {
 471       seq[i]=buffer[i];
 472     }
 473   }
 474
 475
 476
 477
 478
 479   int total_len=imsize;
 480   int rp=1;
 481   int len= total_len/h2;
 482
 483
 484
 485   uchar *mix=new uchar[256];
 486
 487
 488
 489
 490   for (int i = 0; i < 256 ; i++) {
 491     mix[i]=Secretkey[i]^counter[i];
 492
 493   }
 494   gchar  *sha512;
 495
 496   sha512 = g_compute_checksum_for_string(G_CHECKSUM_SHA512, (const char*) mix, 256);
 497 //  g_print("%s\n", sha512);
 498
 499
 500
 501
 502
 503
 504
 505
 506
 507 //  cout<<"hash "<<endl;
 508   for (int i = 0; i < 64 ; i++) {
 509 //    DK[i]=digest[i];
 510     DK[i]=sha512[i];
 511   }
 512   g_free(sha512);
 513
 514
 515   int *Pbox=new int[len];
 516   int *PboxRM=new int[h2];
 517   uchar Sbox1[256];
 518   uchar Sbox2[256];
 519   uchar Inv_Sbox1[256];
 520   uchar Inv_Sbox2[256];
 521   uchar sc[256];
 522   uchar RM1[h2];
 523   uchar RM1_copy[h2];
 524   uchar RMtmp[h2];
 525
 526
 527   uint myrand=0;
 528
 529
 530   double time_encrypt=0;
 531   double time_decrypt=0;
 532
 533
 534   double t=TimeStart();
 535   rc4key(DK, Sbox1, 8);
 536
 537
 538   rc4key(&DK[8], Sbox2, 8);
 539
 540   rc4key(&DK[16], sc, 16);
 541
 542
 543   prga(sc, h2, RM1);
 544
 545
 546   rc4keyperm(&DK[32], len, rp, Pbox, 16);
 547
 548
 549   rc4keyperm(&DK[48], h2, rp, PboxRM, 16);
 550
 551   //time+=TimeStop(t);
 552   //cout<<"Time initializaton "<<time<<endl;
 553
 554
 555
 556   myrand=0;
 557   for(int i=0;i<32;i++) {
 558     myrand|=DK[i]&1;
 559     myrand<<=1;
 560   }
 561   uint myrand_copy=myrand;
 562
 563
 564
 565
 566
 567
 568   for(int i=0;i<h2;i++){
 569     RM1_copy[i]=RM1[i];
 570   }
 571
 572
 573   inverse_tables(Sbox1,256,Inv_Sbox1);
 574   inverse_tables(Sbox2,256,Inv_Sbox2);
 575
 576
 577
 578
 579
 580   time_encrypt=0;
 581   t=TimeStart();
 582
 583   int i;
 584   switch(h) {
 585   case 4:
 586     for(i=0;i<nb_test;i++)
 587     {
 588       if(ctr)
 589         encrypt_ctr<4*4>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,myrand,1);
 590       else
 591         encrypt<4*4>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,myrand,0);
 592
 593     }
 594     break;
 595   case 8:
 596     for(i=0;i<nb_test;i++)
 597     {
 598       if(ctr)
 599         encrypt_ctr<8*8>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,myrand,1);
 600       else
 601         encrypt<8*8>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,myrand,0);
 602
 603     }
 604     break;
 605   case 16:
 606     for(i=0;i<nb_test;i++)
 607     {
 608       if(ctr)
 609         encrypt_ctr<16*16>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,myrand,1);
 610       else
 611         encrypt<16*16>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,myrand,0);
 612
 613     }
 614     break;
 615   case 32:
 616     for(i=0;i<nb_test;i++)
 617     {
 618       if(ctr)
 619         encrypt_ctr<32*32>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,myrand,1);
 620       else
 621         encrypt<32*32>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,myrand,0);
 622
 623     }
 624     break;
 625   case 64:
 626     for(i=0;i<nb_test;i++)
 627     {
 628       if(ctr)
 629         encrypt_ctr<64*64>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,myrand,1);
 630       else
 631         encrypt<64*64>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,myrand,0);
 632
 633     }
 634     break;
 635   case 128:
 636     for(i=0;i<nb_test;i++)
 637     {
 638       if(ctr)
 639         encrypt_ctr<128*128>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,myrand,1);
 640       else
 641         encrypt<128*128>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,myrand,0);
 642
 643     }
 644     break;
 645   }
 646   time_encrypt+=TimeStop(t);
 647   //cout<<"Time encrypt "<<
 648   cout<<(double)imsize*nb_test/time_encrypt<<"\t";
 649
 650
 651   if(lena) {
 652     for(int i=0;i<oneD;i++) {
 653       data_R[i]=seq2[i];
 654       data_G[i]=seq2[oneD+i];
 655       data_B[i]=seq2[2*oneD+i];
 656     }
 657     store_RGB_pixmap("lena2.ppm", data_R, data_G, data_B, width, height);
 658   }
 659
 660
 661   time_decrypt=0;
 662   t=TimeStart();
 663   switch(h) {
 664   case 4:
 665     for(i=0;i<nb_test;i++) {
 666       if(ctr)
 667         encrypt_ctr<4*4>(seq2, seq,len,RM1_copy,Pbox,PboxRM,Sbox1,Sbox2,myrand,0);
 668       else
 669         decrypt<4*4>(seq2,seq,len,RM1_copy,Pbox,PboxRM,Inv_Sbox1,Inv_Sbox2,myrand,0);
 670     }
 671     break;
 672   case 8:
 673     for(i=0;i<nb_test;i++) {
 674       if(ctr)
 675         encrypt_ctr<8*8>(seq2, seq,len,RM1_copy,Pbox,PboxRM,Sbox1,Sbox2,myrand,0);
 676       else
 677         decrypt<8*8>(seq2,seq,len,RM1_copy,Pbox,PboxRM,Inv_Sbox1,Inv_Sbox2,myrand,0);
 678     }
 679     break;
 680   case 16:
 681     for(i=0;i<nb_test;i++) {
 682       if(ctr)
 683         encrypt_ctr<16*16>(seq2, seq,len,RM1_copy,Pbox,PboxRM,Sbox1,Sbox2,myrand,0);
 684       else
 685         decrypt<16*16>(seq2,seq,len,RM1_copy,Pbox,PboxRM,Inv_Sbox1,Inv_Sbox2,myrand,0);
 686     }
 687     break;
 688   case 32:
 689     for(i=0;i<nb_test;i++) {
 690       if(ctr)
 691         encrypt_ctr<32*32>(seq2, seq,len,RM1_copy,Pbox,PboxRM,Sbox1,Sbox2,myrand,0);
 692       else
 693         decrypt<32*32>(seq2,seq,len,RM1_copy,Pbox,PboxRM,Inv_Sbox1,Inv_Sbox2,myrand,0);
 694     }
 695     break;
 696   case 64:
 697     for(i=0;i<nb_test;i++) {
 698       if(ctr)
 699         encrypt_ctr<64*64>(seq2, seq,len,RM1_copy,Pbox,PboxRM,Sbox1,Sbox2,myrand,0);
 700       else
 701         decrypt<64*64>(seq2,seq,len,RM1_copy,Pbox,PboxRM,Inv_Sbox1,Inv_Sbox2,myrand,0);
 702     }
 703     break;
 704   case 128:
 705     for(i=0;i<nb_test;i++) {
 706       if(ctr)
 707         encrypt_ctr<128*128>(seq2, seq,len,RM1_copy,Pbox,PboxRM,Sbox1,Sbox2,myrand,0);
 708       else
 709         decrypt<128*128>(seq2,seq,len,RM1_copy,Pbox,PboxRM,Inv_Sbox1,Inv_Sbox2,myrand,0);
 710     }
 711     break;
 712   }
 713
 714   time_decrypt+=TimeStop(t);
 715   //cout<<"Time decrypt "
 716   cout<<(double)imsize*nb_test/time_decrypt<<"\t";
 717
 718   if(lena) {
 719     for(int i=0;i<oneD;i++) {
 720       data_R[i]=seq[i];
 721       data_G[i]=seq[oneD+i];
 722       data_B[i]=seq[2*oneD+i];
 723     }
 724     store_RGB_pixmap("lena3.ppm", data_R, data_G, data_B, width, height);
 725   }
 726   else {
 727     bool equal=true;
 728     for(int i=0;i<imsize;i++) {
 729       //cout<<(int)buffer[i]<<endl;
 730       if(buffer[i]!=seq[i]) {
 731         equal=false;
 732       }
 733     }
 734 //    cout<<"RESULT CORRECT: "<<equal<<endl;
 735   }
 736
 737
 738
 739   return 0;
 740 }