#include
#include

main()
 {
   char a[20],fs[50]="",t[6],r[5];
   int i,j,p=0,q=0;
   clrscr();
   printf("enter bit string : ");
   scanf("%s",a);
   strcat(fs,"01111110");

   if(strlen(a)<5)
     {
      strcat(fs,a);
     }
   else
     {
      for(i=0;i	{
	  for(j=i;j	    {
	      t[p++]=a[j];
	    }
	  t[p]='\0';
	  if(strcmp(t,"11111")==0)
	    {
	      strcat(fs,"111110");
	      i=j-1;
	    }
	  else
	    {
	      r[0]=a[i];
	      r[1]='\0';
	      strcat(fs,r);
	    }
	  p=0;
	}
     for(q=i;q       {
	 t[p++]=a[q];
       }
     t[p]='\0';
     strcat(fs,t);
   }
   strcat(fs,"01111110");
   printf("After stuffing : %s",fs);

   getch();
 }

#include
#include

main()
 {
   char a[30],fs[50]="",t[3],sd,ed,x[3],s[3],d[3],y[3];
   int i,j,p=0,q=0;
   clrscr();
   printf("Enter characters to be stuffed : ");
   scanf("%s",a);
   printf("\nEnter a character that represents starting delimiter : ");
   scanf(" %c",&sd);
   printf("\nEnter a character that represents ending delimiter   : ");
   scanf(" %c",&ed);
   x[0]=s[0]=s[1]=sd;
   x[1]=s[2]='\0';
   y[0]=d[0]=d[1]=ed;
   d[2]=y[1]='\0';
   strcat(fs,x);

   for(i=0;i     {
       t[0]=a[i];
       t[1]='\0';
       if(t[0]==sd)
	   strcat(fs,s);
       else
	 if(t[0]==ed)
	    strcat(fs,d);
      else
	strcat(fs,t);
    }
   strcat(fs,y);
   printf("\nAfter stuffing : %s",fs);

   getch();
  }

#include
const char * bindiv(const char *,const char *);
const char * binsub(const char *,const char *);
int f=0,ll=0;

main()
 {
   char *a,p[13]="1100000001011",g[30],g1[30],yy[30]="",td[30],*aa;
   int l=0,i;
   clrscr();
   printf("enter transfered data : ");
   scanf("%s",g);
   printf("enter received data : ");
   scanf("%s",td);
   strcpy(g1,g);
   strcat(g,"000000000000");
   printf("\n%s ) %s (",p,g);
   a=bindiv(g,p);

   if(strlen(a)<12)
    {
      for(i=strlen(a);i<12;i++)
	 {
	   yy[l++]='0';
	 }
      yy[l]='\0';
    }

   strcat(yy,a);
   strcat(g1,yy);
   printf("\ncrc is          %s",yy);
   printf("\n                ------------------");
   strcat(td,yy);
   printf("\n\n%s ) %s (",p,td);
   ll=0;
   aa=bindiv(td,p);
   strcpy(a,aa);
   printf("\n                %s",a);
   printf("\n                -----------------");

   if(f==1)
     printf("\ndata transfered correctly");
   else
     printf("\ndata transfered incorrectly");
   getch();

 }

const char * bindiv(const char *s,const char *d)
  {
    int i,j,k=0,x=13,h,p=0,l;
    char q[15]="",b[30],*w;
    for(i=0;i      {
	if((i+x)>strlen(s))
	    x=(i+x)-strlen(s)+1;
	for(j=i;j<(i+x);j++)
	  {
	     b[k++]=s[j];
	  }
       b[k]='\0';
       if(ll!=0)
	   printf("\n                %s",b);
       ll=1;
       if(strlen(b)==12)
	 {
	   break;
	 }
	   printf("\n                %s",d);
	   printf("\n                -----------------");
       w=binsub(b,d);

       k=0;i=j-1;
       for(l=0;l	 {
	   if(w[l]=='1')
	      break;
	 }
       if(l==strlen(w))
	 {
	  f=1;
	  return(w);
	 }

       for(h=l;h	{
	  q[p++]=w[h];
	}
       q[p]='\0';
       x=13-strlen(q);
       strcpy(b,"");
       strcat(b,q);
       k=strlen(q); p=0;
      }
    return(b);
  }

const char * binsub(const char *x,const char *y)
  {
    int i,j=0;

    char w[15]="",e[3],f[3],n[3];
    e[0]='1';
    e[1]='\0';
    f[0]='0';
    f[1]='\0';

    for(i=0;i      {
	 if((x[i]=='1')&&(y[i]=='1'))
	     strcat(w,f);
	 else
	  if((x[i]=='0')&&(y[i]=='0'))
	     strcat(w,f);
	 else
	    strcat(w,e);
      }

     n[0]='\0';
     n[1]='\0';
     strcat(w,n);
     return(w);
  }

#include
const char * bindiv(const char *,const char *);
const char * binsub(const char *,const char *);
int f=0,ll=0;

main()
 {
   char *a,p[20]="10001000000100001",
   g[30],g1[30],yy[30]="",td[30],*aa;
   int l=0,i;
   clrscr();
   printf("enter transfered data : ");
   scanf("%s",g);
   printf("enter received data : ");
   scanf("%s",td);
   strcpy(g1,g);
   strcat(g,"0000000000000000");
   printf("\n%s ) %s (",p,g);
   a=bindiv(g,p);
   if(strlen(a)<16)
    {
      for(i=strlen(a);i<16;i++)
	 {
	   yy[l++]='0';
	 }
      yy[l]='\0';
    }

   strcat(yy,a);
   strcat(g1,yy);
   printf("\n                    ------------------");
   printf("\ncrc is              %s",yy);
   strcat(td,yy);
   printf("\n\n%s ) %s (",p,td);
   ll=0;
   aa=bindiv(td,p);
   strcpy(a,aa);
   printf("\n                    %s",a);
   printf("\n                    -----------------");
   if(f==1)
     printf("\ndata transfered correctly");
   else
     printf("\ndata transfered incorrectly");
   getch();

 }

const char * bindiv(const char *s,const char *d)
  {
    int i,j,k=0,x=17,h,p=0,l;
    char q[25]="",b[30],*w;
    for(i=0;i      {
	if((i+x)>strlen(s))
	    x=(i+x)-strlen(s)+1;
	for(j=i;j<(i+x);j++)
	  {
	     b[k++]=s[j];
	  }

       b[k]='\0';
       if(ll!=0)
	   printf("\n                    %s",b);
       ll=1;
       if(strlen(b)==16)
	 {
	   break;
	 }
	   printf("\n                    %s",d);
	   printf("\n                    -----------------");
       w=binsub(b,d);

       k=0;i=j-1;
       for(l=0;l	 {
	   if(w[l]=='1')
	      break;
	 }
       if(l==strlen(w))
	 {
	  f=1;
	  return(w);
	 }
       for(h=l;h	{
	  q[p++]=w[h];
	}
       q[p]='\0';
       x=17-strlen(q);
       strcpy(b,"");
       strcat(b,q);
       k=strlen(q); p=0;
      }
    return(b);
  }


const char * binsub(const char *x,const char *y)
  {
    int i,j=0;
    char w[25]="",e[3],f[3],n[3];
    e[0]='1';
    e[1]='\0';
    f[0]='0';
    f[1]='\0';
    for(i=0;i      {
	 if((x[i]=='1')&&(y[i]=='1'))
	     strcat(w,f);
	 else
	  if((x[i]=='0')&&(y[i]=='0'))
	     strcat(w,f);
	 else
	    strcat(w,e);
      }
     n[0]='\0';
     n[1]='\0';
     strcat(w,n);
     return(w);
  }

#include

void sort(void);

static int dsp[10][10],nodes;
struct{
  char src;
  char dest;
  int length;
}stemp,permanent[10]={' ',' ',0},temp[10]={' ',' ',-1};
static int perm,tem;

void main()
{
  int i,j,k,l,m,n=0,point;
  char initial,dest,path[10]={' '};
  clrscr();
  printf("\t\t Shortest Path (Dijkstra's algorithm)");
  printf("\n*******************************************************");
  printf(“\nEnter the number of nodes:”);
  scanf(“%d”,&nodes);
  printf(“\nEnter the adjacency matrix for the graph:\n”);
 
  for(i=0;i  {
       for(j=0;j 		 scanf(“%d”,&dsp[I][j]);
  }
  fflush(stdin);
  printf("\n enter the source node:");
  scanf("%c",&initial);fflush(stdin);
  printf("\n Enter the destination node:");
  scanf("%c",&dest);
  permanent[perm].src=initial;
  permanent[perm].dest=initial;
  permanent[perm++].length=0;
  i=permanent[perm-1].dest-97;
  
  for(j=0;j  { 
      if(i!=j)
      {
        if(dsp[i][j]>0)
        {
             temp[tem].src=permanent[perm-1].src;
             temp[tem].dest=j+97;
             temp[tem++].length=dsp[i][j];
        }
     }
  }
  sort();
  
  while(tem>=0)
  {    
j=permanent[perm-1].dest-97;
     for(i=0;i     {
         if(i!=initial-97)
         {
             if(dsp[j][i]>0)
             {  
  l=-1;
                 for(k=0;k          	  {
	   if(permanent[k].dest==(i+97))	      
l=k;
            }
                 for(k=0;k<=tem;k++)
                 {
  		   if(temp[k].dest==(i+97))	     
  l=k;
            }
		  if(l<0)
            {
			temp[tem].src=j+97;
		temp[tem].dest=i+97;
			for(m=0;m			{
  		    if(permanent[m].dest==temp[tem].src)
  		        n=permanent[m].length;
			}
		temp[tem++].length=dsp[j][i]+n;
		  }

	  else
	  {	     
		       for(m=0;m	     	     {
		  	if(permanent[m].dest==j+97)
		  	{   
n=permanent[m].length+dsp[j][i];break;
}
		  	else
		    		n=dsp[j][i];
  	     	     }
	     if((n		     {     
 temp[l].length=n;
		 temp[l].src=j+97;
			 temp[l].dest=i+97;
                    }
	  	}
     	       }
        }
    }
    sort();
 }
  printf("\nShortest path:\n");
  printf("From %c to %c is:",initial,dest);

  for(i=0;i  {
      if(permanent[i].dest==dest)
      {
      	point=i;n=i;      break;
      }
  }   i=0;
  
  for(j=perm;j>0;j--)
  {
       if(permanent[j-1].dest==permanent[point].src)
    	  {
path[i++]=permanent[point].dest; 
point=j-1;
  }
  }
  path[i]=initial;
  for(j=i;j>=0;j--)
  printf("%c ",path[j]);
  printf("\t length=%d",permanent[n].length);
  getch();
 }

void sort()
{  
int i,j,k;
   	for(i=0;i<=tem;i++)
{ 
     k=1;
      for(j=0;j<=tem;j++)
      	     {
		if((temp[j].length <= temp[j+1].length))
		{
  	      stemp=temp[j];
   	      temp[j]=temp[j+1];
	      temp[j+1]=stemp;	   k=0;
		}
      	     }
      if(k)
		break;
   	}
   permanent[perm++]=temp[tem-1];
   temp[tem-1].src=' ';temp[tem-1].dest=' ';
   temp[tem-1].length=-1;   tem--;
}

    START

		  read data from user:
	        nodes=no. of nodes;src=node for which distance vector
	    is to be computed;neighb=no. of neighbours to src;
	neigh[]={src,neighbouring node names};
     topology[nodes][nodes]=distance vectors from all neighbours
  are read from user and stored. for nodes that are not neighbours
infinity is stored as the value. dv[] stores the distance vector of src


		    		for(I=0;I

					
 if(I==neigh[n])

	       yes

				add1=topology[src][I];
		add add1 to the distance vector of I 

	
				
	compare the values in distace vector of the source.
	to that of I .if the value in distance vector of I less
than the original then store the new value and the
line to use as I .



		display the distance vector
		of src

#include
#define e 10000
#define nodes1 40

int topology[nodes1][nodes1];
static int l,n,neighb,nodes;
static char neigh[nodes1];

struct {
   char name;
   int delay;
         } dv[nodes1];


void main()
{
   int i,j,k[nodes1*nodes1],add=0,src1;
   char src='a';
   clrscr();
   printf("\t\t\tDistance Vector Routing\n");
printf("***********************************************************");
   printf("\nEnter the number of nodes:");
   scanf("%d",&nodes);fflush(stdin);
   printf("\nEnter the node for which Distance Vector table is needed:");
   scanf("%c",&src);fflush(stdin);
   printf("\nEnter the no. of neighbours to %c:",src);
   scanf("%d",&neighb); fflush(stdin);
   printf("\nenter the names of the neighbours(in alphabetic order):");
   neigh[0]=src;
   for(i=1;i   {  
       scanf("%c",&neigh[i]);
       fflush(stdin);
   }
   printf("\n enter the distance vectors of the source and the neighbouring 
                     nodes\n");
   printf("starting with source,then with neighbouring nodes in alphabetical
                order:\n");

   
for(i=0;i   {
       scanf("%d",&k[i]);
   }
   src1=src;
   l=nodes;n=1;
   
for(i=0;i   {
       if(i==src1-97)
     {
     for(j=0;j        {
	if(k[j]<0)
	  topology[i][j]=e;
	else
	  topology[i][j]=k[j];
        }
     }
        else if(i==neigh[n]-97)
     {
       for(j=0;j         {  if(k[l]<0)
	    topology[i][j]=e;
	  else
	    topology[i][j]=k[l];
	l++;
        } n++;
     }
       else
     {
       for(j=0;j	 topology[i][j]=e;
     }
   }
   i=src1-97;
   for(j=0;j   {   dv[j].name=src1;
       dv[j].delay=topology[i][j];
   }
   k[nodes*nodes]=e; n=1;

   
for(i=0;i    {
    if((i==neigh[n]-97))
     {
     add=topology[src1-97][i];
     for(j=0;j       {
	k[j]=add+topology[i][j];
       }
     

  for(j=0;j     {
       if(k[j]       {
	 dv[j].name=i+97;
	 dv[j].delay=k[j];
       }
     }
     if(i!=src1-97)
       n++;

     printf("\n%c's distance vector after receiving %c's vector:\n",src1,i+97);
     for(j=0;j     printf("To %c:\tfrom: %c \t %d\n",j+97,dv[j].name,dv[j].delay);
     
 getch();

     }
  }
}

#include
int max();
int distance[20];
int n;

main()
{
 int adj[20][20],adj1[20][20],flag[30];
 int i,j,root,x;
 int source,count=1,y=0;
 printf("enter no of nodes");
 scanf("%d",&n);

 for(i=0;i  {
   for(j=0;j    {
     scanf("%d",&adj[i][j]);
     }
    }

  printf("enter the source for broadcasting");
  scanf("%d",&source);
  
  for(i=0;i   {
    flag[i]=0;
    }
  
for(root=0;root   {
    for(i=0;i     {
      distance[i]=adj[root][i];
      }
      x=min();
     
 for(i=0;i       {
	
     if(distance[i]==x)
	 {
	  adj1[root][i]=x;
	  adj1[i][root]=x;
	  }
	else
	 {
	  adj1[root][i]=0;
	  }
	}
    }

    for(i=0;i      {
       for(j=0;j       {
	if(adj1[i][j]!=0)
	{
	 adj1[j][i]=adj[i][j];
	 }
       }
      }

     printf("given adjacency matrix is");
    
 for(i=0;i      {
       for(j=0;j	{
	 printf("%d",adj[i][j]);
	 }
	 printf("\n");
       }
     printf("minimal spanning tree");

 for(i=0;i      {
     for(j=0;j       {
	printf("%d ",adj1[i][j]);
	}
	printf("\n");
      }
      root=source;
      flag[root]=1;
     
 

while(count!=y)
   {
	for(i=0;i	 {
	  if(adj1[root][i]!=0 && flag[root]==1 && flag[i]!=1)
	   {
	    printf("%d sends message to %d \n",root,i);
	    flag[i]=1;
	    }
	  }
	 if(root	  {
	   root++;
	   }
	   else
	    {
	     root=0;
	     }
	  for(i=0;i	   {
	    if(flag[i]==0)
	     {
	      break;
	      }
     }
	 
 if(i==n)
	   {
	    count=y;
	    }
       }
   }

int min()
  {
       int i,j=0;
       int mini;
       int distance1[10];
       for(i=0;i       {
	 if(distance[i]!=0)
	  {
	   distance1[j]=distance[i];
	   j++;
	   }
         }
       mini=distance1[0];
      
      for(i=1;i	{
	   if(distance1[i]	    {
	     mini=distance1[i];
	     }
	 }
	   return(mini);
     }

#include
#include

void keygen();
 int len,x,y = 0,l[40],r[40],r1[48],str1[20], r2[48],i3,     tmp3 [64],tmp4[64];  
   
 int ip [] = {58,50,42,34,26,18,10,2,60,52,44,36,
28,20,12,4,62,54,46,38,30,22,14,6,64,56,48,40,32,24,16,8,57,49,41,33,25,17,9,1,59,51,43,35,27,19,11,3,61,53,45,37,29,21,13,5,63,55,47,39,31,23,15,7};

 int   e []    =  {32,1,2,3,4,5,4,5,6,7,8,9,8,9,10,11,12,13,12,
13,14,15,16,17,16,17,18,19,20,21,20,21,22,23,24,25,24,25,26,27,28,29,28,29,30,31,32,1};

 int c1[100];
 int s[64];
 int round=1;

 int k [] = {0,1,0,1,0,1,0,0,1,0,1,0,1,0,1,1,0,0,0,0,0,1,
1,1,1,1,1,0,0,0,0,0,0,  0,1,1,1,1,1,0,1,1,1,1,1,1,1,0,0,
1,1,1,1,1,1,1,1,0,0,0,0,0,1,1};

 int pc1 [] = {57,49,41,33,25,17,9,1,58,50,42,34,26,18,10,2,
59,51,43,35,27,19,11,3,60,52,44,36,63,55,47,39,31,23,15,7,62,54,46,38,30,22,14,6,61,53,45,37,29,21,13,5,28,20,12,4};
 
int pc2[]={14,17,11,24,1,5,3,28,15,6,21,10,23,19,12,
4,26,8,16,7,27,20,13,2,41,52,31,37,47,55,30,40,51,45,33,48,44,49,39,56,34,53,46,42,50,36,29,32};
 
int tmp5[8],flag=0,t,t1,i,j=0,c2[100],c[100],d[100],
key[100],k2[20][100],count=1;

 int s1[4][16]={{14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7},
		 {0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8},
		 {4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0},
		 {15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13}};
  int s2[4][16]={{15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10},
		 {3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5},
		 {0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15},
		 {13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9}};
  int s3[4][16]={{10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8},
		 {13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1},
		 {13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7},
		 {1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12}};
  int s4[4][16]={{7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15},
		 {13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9},
		 {10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4},
		 {3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14}};
  int s5[4][16]={{2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9},
		 {14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6},
		 {4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14},
		 {11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3}};
  int s6[4][16]={{12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11},
		 {10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8},
		 {9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6},
		 {4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13}};
  int s7[4][16]={{4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1},
		 {13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6},
		 {1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2},
		 {6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12}};
  int s8[4][16]={{13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7},
		 {1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2},
		 {7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8},
		 {2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11}};
 
 int p[32]={16,7,20,21,29,12,28,17,1,15,23,26,5,18,
31,10,2,8,24,14,32,27,3,9,19,13,30,6,22,11,4,25};
  
int g3,w[8],i4,d1=0,g,g1=0,g2,size,ch1[8],a1[4],b1[8][4],
b[8][6],i1,j1,k1=0,tz[4],tmp,tmp1,t11,temp,z=0,m,count1=0,c11[32],res[32];
  
int iip[]={40,8,48,16,56,24,64,32,39,7,47,15,55,23,
63,31,38,6,46,14,54,22,62,30,37,5,45,13,53,21,61,29,36,4,44,12,52,20,60,28,35,3,43,11,51,19,59,27,34,2,42,10,50,18,58,26,33,1,41,9,49,17,57,25};

 char ch[20];
 int str[64];

void main()
 {
  clrscr();
  printf("enter the string\n");
  gets(ch);
  size=strlen(ch);

  for(g=0;g  {
    ch1[g]=ch[g];
  }

 for(g=0;g {
  g1=0;
   while(ch1[g]>0)
   {
   w[g1++]=ch1[g]%2;
   ch1[g]=ch1[g]/2;
    }
  for(g3=g1;g3<8;g3++)
    w[g3]=0;
  
for(g2=7;g2>=0;g2--)
    {
   str[d1++]=w[g2];
    }
  }

 for(g3=0;g3<64;g3++)
    s[g3]=str[g3];
 
for(g2=0;g2<64;g2++)
   printf("%d",str[g2]);
  keygen();	/*16 key generation*/
 
 /*initial permutation*/
  for(x=0;x<64;x++)
 {
  c1[x]=str[ip[x]-1];
 }

 for(x=0;x<64;x++)
 {
  printf("%d",c1[x]);
  if(((x%7)==0)&&(x!=0))
  printf("\n");
  }


 /*dividing the whole string into l & r*/

 for(x=0;x<32;x++)
    l[x]=c1[x];
 y=0;
 for(x=32;x<64;x++)
    r[y++]=c1[x];

 /*round starts here*/
 while(round<=16)
 {

 /*expansion permutation e table*/
 for(x=0;x<48;x++)
    {
     r1[x]=r[e[x]-1];
     }
 printf("r1: ");
 for(x=0;x<48;x++)
    printf("%d",r1[x]);
    printf("\n");

 /*xor r1 with key*/
 for(x=0;x<48;x++)
  {
   if(r1[x]==k2[round][x])
      r2[x]=0;
   else
      r2[x]=1;
   }
 printf("\nkey");
 for(x=0;x<48;x++)
   printf("%d",k2[round][x]);
 printf("\n");
 for(x=0;x<48;x++)
   printf("%d",r2[x]);

 /*substitution s-box*/
 k1=0;
for(i1=0;i1<8;i1++)
    {
     for(j1=0;j1<6;j1++)
	{
	 b[i1][j1]=r2[k1++];
	 }
    }
  count1=0;
  for(i1=0;i1<8;i1++)
   {
    count1++;
    tz[0]=b[i1][0];
    tz[1]=b[i1][5];
    tmp=(tz[0]*2)+tz[1];
    k1=0;
    printf("\n");
    for(j1=1;j1<5;j1++)
     {
      tz[k1]=b[i1][j1];
      printf("%d",tz[k1]);
      k1++;
      }
    tmp1=(tz[0]*8)+(tz[1]*4)+(tz[2]*2)+tz[3];
  
  switch(count1)
     {
      case 1 : temp=s1[tmp][tmp1];
	       break;
      case 2 : temp=s2[tmp][tmp1];
	       break;
      case 3 : temp=s3[tmp][tmp1];
	       break;
      case 4 : temp=s4[tmp][tmp1];
	       break;
      case 5 : temp=s5[tmp][tmp1];
	       break;
      case 6 : temp=s6[tmp][tmp1];
	       break;
      case 7 : temp=s7[tmp][tmp1];
	       break;
      case 8 : temp=s8[tmp][tmp1];
	       break;
      }

    printf("temp is %d",temp);
    t11=0;
   
 if(temp==0)
     {
      for(m=0;m<4;m++)
	b1[i1][m]=0;
      }
 
 else
     {
      while(temp>0)
      {
       a1[t11]=temp%2;
       temp=temp/2;
       t11++;
      }
 
 for(m=t11;m<4;m++)
     a1[m]=0;
  z=0;
  for(m=3;m>=0;m--)
     {
      b1[i1][z++]=a1[m];
      }
  }
  }
 
 k1=0;
  printf("b1 is\n");
  for(i1=0;i1<8;i1++)
   {
    for(j1=0;j1<4;j1++)
     printf("%d",b1[i1][j1]);
    printf("\n");
   }

 for(i1=0;i1<8;i1++)
   {
    for(j1=0;j1<4;j1++)
      c11[k1++]=b1[i1][j1];
   }

 /*permutation after substitution*/

 for(i1=0;i1<32;i1++)
   res[i1]=c11[p[i1]-1];
 for(i1=0;i1<32;i1++)
   printf("%d",c11[i1]);
 printf("after substn\n");
 for(i1=0;i1<32;i1++)
   printf("%d",res[i1]);
 printf("xor l[i] with res[i]\n");
 

 for(i1=0;i1<32;i1++)
   {
    if(l[i1]==res[i1])
       res[i1]=0;
    else
      res[i1]=1;
    }
 for(i1=0;i1<32;i1++)
    l[i1]=r[i1];
 for(i1=0;i1<32;i1++)
    r[i1]=res[i1];
printf("left and right for next round\n");
 
for(i1=0;i1<32;i1++)
    printf("%d",l[i1]);
 printf("\n");
 for(i1=0;i1<32;i1++)
    printf("%d",r[i1]);
 round++;
 }

for(i3=0;i3<32;i3++)
 {
   tmp3[i3]=r[i3];
 }
 i4=0;
 for(i3=32;i3<64;i3++)
  {
   tmp3[i3]=l[i4++];
  }
printf("\nafter swapping\n");

for(i3=0;i3<64;i3++)
  printf("%d",tmp3[i3]);

for(i3=0;i3<64;i3++)
  {
   tmp4[i3]=tmp3[iip[i3]-1];
   }
 printf("output is\n");

 for(i3=0;i3<64;i3++)
  printf("%d",tmp4[i3]);
  j=0;
 

 for(i=0;i<64;i++)
   {
    tmp5[j]=(tmp4[i]*128)+(tmp4[i+1]*64)+(tmp4[i+2]*32)+(tmp4[i+3]*16)+(tmp4[i+4]*8)+(tmp4[i+5]*4)+(tmp4[i+6]*2)+tmp4[i+7];

    i=i+7;
    j++;
    }

 printf("\n");
 for(i=0;i<8;i++)
  printf("%c",tmp5[i]);
 getch();
}


void keygen()
 {
  for(i=0;i<56;i++)
    {
      key[i]=k[pc1[i]-1];
      }
   for(i=0;i<28;i++)
     {
      c[i]=key[i];
      }
   for(i=28;i<56;i++)
     {
      d[j++]=key[i];
      }
  
 while(count<17)
   {
    t=c[0];
    t1=d[0];
    for(i=0;i<27;i++)
      {
       c[i]=c[i+1];
       d[i]=d[i+1];
       }
   
 if(i==27)
      {
       c[i]=t;
       d[i]=t1;
       }
   if((count==1)||(count==2)||(count==9)||(count==16))
      count++;
   else if(flag==1)
      {
       count++;
       flag=0;
       }
   else
      flag=1;
   if(flag==0)
    {
     for(i=0;i<28;i++)
       c2[i]=c[i];
     j=0;
     for(i=28;i<56;i++)
       c2[i]=d[j++];
     for(i=0;i<48;i++)
       k2[count-1][i]=c2[pc2[i]-1];
     }
   }
  }

#include
#include
#include

void main()
 {
  char a[]={"0ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
  int n,i,j,s,n2,k1,p,q,d,m1,e1,l5,z,p2[30],s1,c[30];
  unsigned long int l3,m,l4,k2;
  double l2,l1,l6;
  float e,l;
  char p1[30];
  clrscr();

  printf("enter two prime numbers p and q\n");
  scanf("%d %d",&p,&q);
    do{
    n=p*q;
    if(n<26)
    {  printf("\n n value is not large enough.\nplease select p, q value such that p*q is greater than 26");
      scanf("%d %d",&p,&q);}
  }while(n<26);

  z=((p-1)*(q-1));
  printf("enter the value of  d:\n");
  scanf("%d",&d);
 for(j=1;j {
   if((j*d)%z==1)
     break;
 }
  e=j;
  printf("%d	%d	%f\n",n,z,e);
  printf("ENCRYPTION-CIPHERTEXT");
  printf("enter the plain text\n");
  scanf("%s",p1);

 for(i=0;i   {
   for(j=1;j     {
	if(a[j]==p1[i])
	 {
	  s=j;
	  break;
	 }
	else
	  continue;
      }
printf("%d",s);
  e1=(int)e;
  l1=pow(((double)s),((double)e1));
    k2=fmod(l1,(double)n);
  printf("\n%lu\n",k2);
  c[i]=(int)k2;
  printf("cipher:%d\n",c[i]);
    }
    printf("\n");
 for(i=0;i    {
	l2=(pow(((double)c[i]),((double)d)));
	 m=fmod(l2,(double)n);
	  m1=(int)m;
	printf(" %c\n",a[m1]);}
       getch();
  }