Verilog Program for 4x1 MUX

module mux4x1(y,i,s);
    input [0:3]i;
    input [0:1]s;
    output y;
    assign y=(i[0]&~s[0]&~s[1])|(i&s[0]&s[1])|(i[2]&s[0]&~s[1])|(i[3]&s[0]&s[1]);
endmodule;

Verilog Program for 2x1 MUX

module mux2x1(y,i0,i1,s);
    input i0,i1;
    input s;
    output y;
    assign y=(i0&(~s))|(i1&s);
endmodule;

Verilog Program for 32-bit Carry Look Ahead Adder

module cla_32bit(a,b,cin,sum,cout);
    input [31:0]a,b;
    input cin;
    output [31:0]sum;
    output cout;
    //assign cin=1'b0;
    wire p0,p1,g0,w0;
    and (g0,a[0],b[0]);
    xor (p0,a[0],b[0]);
    and (w0,p0,cin);
    or (cout,g0,w0);
    xor (p0,a[0],b[0]);
    xor (p1,a[1],b[1]);
    xor (p2,a[2],b[2]);
    xor (p3,a[3],b[3]);
    xor (p4,a[4],b[4]);
    xor (p5,a[5],b[5]);
    xor (p6,a[6],b[6]);
    xor (p7,a[7],b[7]);
    xor (p8,a[8],b[8]);
    xor (p9,a[9],b[9]);
    xor (p10,a[10],b[10]);
    xor (p11,a[11],b[11]);
    xor (p12,a[12],b[12]);
    xor (p13,a[13],b[13]);
    xor (p14,a[14],b[14]);
    xor (p15,a[15],b[15]);
    xor (p16,a[16],b[16]);
    xor (p17,a[17],b[17]);
    xor (p18,a[18],b[18]);
    xor (p19,a[19],b[19]);
    xor (p21,a[20],b[20]);
    xor (p20,a[21],b[21]);
    xor (p22,a[22],b[22]);
    xor (p23,a[23],b[23]);
    xor (p24,a[24],b[24]);
    xor (p25,a[25],b[25]);
    xor (p26,a[26],b[26]);
    xor (p27,a[27],b[27]);
    xor (p28,a[28],b[28]);
    xor (p29,a[29],b[29]);
    xor (p30,a[30],b[30]);
    xor (p31,a[31],b[31]);
    xor (sum[0],p0,cin);
    xor (sum[1],p1,c1);
    xor (sum[2],p2,c2);
    xor (sum[3],p3,c3);
    xor (sum[4],p4,c4);
    xor (sum[5],p5,c5);
    xor (sum[6],p6,c6);
    xor (sum[7],p7,c7);
    xor (sum[8],p8,c8);
    xor (sum[9],p9,c9);
    xor (sum[10],p10,c10);
    xor (sum[11],p11,c11);
    xor (sum[12],p12,c12);
    xor (sum[13],p13,c13);
    xor (sum[14],p14,c14);
    xor (sum[15],p15,c15);
    xor (sum[16],p16,c16);
    xor (sum[17],p17,c17);
    xor (sum[18],p18,c18);
    xor (sum[19],p19,c19);
    xor (sum[20],p20,c20);
    xor (sum[21],p21,c21);
    xor (sum[22],p22,c22);
    xor (sum[23],p23,c23);
    xor (sum[24],p24,c24);
    xor (sum[25],p25,c25);
    xor (sum[26],p26,c26);
    xor (sum[27],p27,c27);
    xor (sum[28],p28,c28);
    xor (sum[29],p29,c29);
    xor (sum[30],p30,c30);
    xor (sum[31],p31,cout);
endmodule;

Verilog Program for 8-bit Carry Look Ahead Adder

module cla_8bit(a,b,cin,sum,cout);
    input [7:0]a,b;
    input cin;
    output [7:0]sum;
    output cout;
    //assign cin=1'b0;
    wire p0,p1,g0,w0;
    and (g0,a[0],b[0]);
    xor (p0,a[0],b[0]);
    and (w0,p0,cin);
    or (cout,g0,w0);
    xor (p0,a[0],b[0]);
    xor (p1,a[1],b[1]);
    xor (p2,a[2],b[2]);
    xor (p3,a[3],b[3]);
    xor (p4,a[4],b[4]);
    xor (p5,a[5],b[5]);
    xor (p6,a[6],b[6]);
    xor (p7,a[7],b[7]);
xor (sum[0],p0,cin);
xor (sum[1],p1,c1);
xor (sum[2],p2,c2);
xor (sum[3],p3,c3);
xor (sum[4],p4,c4);
xor (sum[5],p5,c5);
xor (sum[6],p6,c6);
xor (sum[7],p7,cout);
endmodule;

Verilog Program for 8-bit Carry Skip Adder

module CSA8(cout,S,A,B,cin);
    output [7:0]S;
    output cout;
    input [7:0]A,B;
    input cin;
    wire c1,c2,c3,C4,C5,C6,C7,P0,P1,P2,P3,p4,p5,p6,p7;
    full_adder F1(S[0],c1,A[0],B[0],CIN);
    full_adder F2(S[1],c2,A[1],B[1],c1);
    full_adder F3(S[2],c3,A[2],B[2],c2);
    full_adder F4(S[3],C4,A[3],B[3],c3);
    full_adder F5(S[4],C5,A[4],B[4],C4);
    full_adder F6(S[5],C6,A[5],B[5],C5);
    full_adder F7(S[6],C7,A[6],B[6],C6);
    full_adder F8(S[7],cout,A[7],B[7],C7);
    and g0(p0,A[0],B[0]);
    and g1(p1,A[1],B[1]);
    and g2(p2,A[2],B[2]);
    and g3(p3,A[3],B[3]);
    and g4(p4,A[4],B[4]);
    and g5(p5,A[5],B[5]);
    and g6(p6,A[6],B[6]);
    and g7(p7,A[7],B[7]);
    mux2x1 m1(cout1,c3,cout,se1);
    mux2x1 m2(cout2,c7,cout1,se2);
    endmodule;

Verilog Program for 4-bit Carry look Ahead Adder

module cla_4bit(a,b,cin,sum,cout);
    input [3:0]a,b;
    input cin;
    output [3:0]sum;
    output cout;
    //assign cin=1'b0;
    wire p0,p1,g0,w0;
    and (g0,a[0],b[0]);
    xor (p0,a[0],b[0]);
    and (w0,p0,cin);
    or (cout,g0,w0);
    xor (p0,a[0],b[0]);
    xor (p1,a[1],b[1]);
    xor (p2,a[2],b[2]);
    xor (p3,a[3],b[3]);
    xor (sum[0],p0,cin);
    xor (sum[1],p1,c1);
    xor (sum[2],p2,c2);
    xor (sum[3],p3,cout);
endmodule;

Verilog Program for 4-bit Carry Skip Adder

module CSA4(cout,S,A,B,cin);
    output [3:0]S;
    output cout;
    input [3:0]A,B;
    input cin;
    wire c1,c2,c3,c4,P0,P1,P2,P3;
    full_adder F1(S[0],c1,A[0],B[0],CIN);
    full_adder F2(S[1],c2,A[1],B[1],c1);
    full_adder F3(S[2],c3,A[2],B[2],c2);
    full_adder F4(S[3],Cout,A[3],B[3],c3);
    and g0(p0,A[0],B[0]);
    and g1(p1,A[1],B[1]);
    and g2(p2,A[2],B[2]);
    and g3(p3,A[3],B[3]);
 mux2x1 m1(cout1,c3,cout,se1);
 endmodule;

Verilog Program for 32-bit Carry Skip Adder

module CSA32(cout,S,A,B,cin);
    output [31:0]S;
    output cout;
    input [31:0]A,B;
    input cin;
    wire c1,c2,c3,C4,C5,C6,C7,c8,c9,c10,c11,c12,c13,c14,c15,c16,c17,c18,c19,c20,c21,c22,c23,c24,c25,c26,c27,c28,c29,c30,c31,
    P0,P1,P2,P3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14,p15,p16,p17,p18,p19,p20,p21,p22,p23,p24,p25,p26,p27,p28,p29,p30,p31;
    full_adder F1(S[0],c1,A[0],B[0],CIN);
    full_adder F2(S[1],c2,A[1],B[1],c1);
    full_adder F3(S[2],c3,A[2],B[2],c2);
    full_adder F4(S[3],C4,A[3],B[3],c3);
    full_adder F5(S[4],C5,A[4],B[4],C4);
    full_adder F6(S[5],C6,A[5],B[5],C5);
    full_adder F7(S[6],C7,A[6],B[6],C6);
    full_adder F8(S[7],c8,A[7],B[7],C7);
    full_adder F9(S[8],C9,A[8],B[8],C8);
    full_adder F10(S[9],c10,A[9],B[9],C9);
    full_adder F11(S[10],c11,A[10],B[10],c10);
    full_adder F12(S[11],c12,A[11],B[11],c11);
    full_adder F13(S[12],C13,A[12],B[12],c12);
    full_adder F14(S[13],C14,A[13],B[13],C13);
    full_adder F15(S[14],C15,A[14],B[14],C14);
    full_adder F16(S[15],C16,A[15],B[14],C15);
    full_adder F17(S[16],c17,A[16],B[15],C16);
    full_adder F18(S[17],C18,A[17],B[16],C17);
    full_adder F19(S[18],c19,A[18],B[17],C18);
    full_adder F20(S[19],c20,A[19],B[18],c19);
    full_adder F21(S[20],c21,A[20],B[19],c20);
    full_adder F22(S[21],C22,A[21],B[21],c21);
    full_adder F23(S[22],C23,A[22],B[22],C22);
    full_adder F24(S[23],C24,A[23],B[23],C23);
    full_adder F25(S[24],C25,A[24],B[24],C24);
    full_adder F26(S[25],c26,A[25],B[25],C25);
    full_adder F27(S[26],C27,A[26],B[26],C26);
    full_adder F28(S[27],c28,A[27],B[27],C27);
    full_adder F29(S[28],c29,A[28],B[28],c28);
    full_adder F30(S[29],c30,A[29],B[29],c29);
    full_adder F31(S[30],C31,A[30],B[30],c30);
    full_adder F32(S[31],COUT,A[31],B[31],C31);
    and g0(p0,A[0],B[0]);
    and g1(p1,A[1],B[1]);
    and g2(p2,A[2],B[2]);
    and g3(p3,A[3],B[3]);
    and g4(p4,A[4],B[4]);
    and g5(p5,A[5],B[5]);
    and g6(p6,A[6],B[6]);
    and g7(p7,A[7],B[7]);
    and g8(p8,A[8],B[8]);
    and g9(p9,A[9],B[9]);
    and g10(p10,A[10],B[10]);
    and g11(p11,A[11],B[11]);
    and g12(p12,A[12],B[12]);
    and g13(p13,A[13],B[13]);
    and g14(p14,A[14],B[14]);
    and g15(p15,A[15],B[15]);
    and g16(p16,A[16],B[16]);
    and g17(p17,A[17],B[17]);
    and g18(p18,A[18],B[18]);
    and g19(p19,A[19],B[19]);
    and g20(p20,A[20],B[20]);
    and g21(p21,A[21],B[21]);
    and g22(p22,A[22],B[22]);
    and g23(p24,A[23],B[23]);
    and g24(p25,A[24],B[24]);
    and g25(se,p0,p1,p2,p3);
    and g26(se2,p4,p5,p6,p7);
    and g27(se3,p8,p9,p10,p11);
    and g28(se4,p12,p13,p14,p15);
    and g29(se5,p16,p17,p18,p19);
    and g30(se6,p20,p21,p22,p23);
    and g31(se7,p24,p25,p26,p27);
    and g32(se8,P28,p29,p30,P31);
    mux2x1 m1(cout1,c3,cout,se1);
    mux2x1 m2(cout2,c7,cout1,se2);
    mux2x1 m3(cout3,c11,cout2,se3);
    mux2x1 m4(cout4,c15,cout3,se4);
    mux2x1 m5(cout5,c19,cout4,se5);
    mux2x1 m6(cout6,c23,cout5,se6);
    mux2x1 m7(cout7,c27,cout6,se7);
    mux2x1 m8(cout8,c28,cout7,se8);
endmodule;

Verilog Program for 32-bit Carry look Ahead Adder

module cla32(s,cout,a,b,cin);
    output [31:0]s;
    output cout;
    input [31:0]a;
    input [31:0]b;
    input cin;
    wire [31:0]p,g,c;
    assign p[31:0]=a[31:0]^b[31:0];
    assign g[31:0]=a[31:0]&b[31:0];
    assign c[0]=g[0]|(p[0]&cin);
    assign c[31:1]=g[31:1]|(p[31:1]&c[31:0]);
    assign s[0]=p[0]^cin;
    assign s[31:1]=p[31:1]^c[31:0];
    assign cout=c[31];
endmodule;

Verilog Program for 32-bit Carry Select Adder

module CSA16(cout,S,A,B,cin);
    output [15:0]S;
    output cout;
    input [15:0]A,B;
    input cin;
    wire c1,c2,c3,C4,C5,C6,C7,c8,c9,c10,c11,c12,c13,c14,c15,c16,P0,P1,P2,P3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14,p15;
    full_adder F1(S[0],c1,A[0],B[0],CIN);
    full_adder F2(S[1],c2,A[1],B[1],c1);
    full_adder F3(S[2],c3,A[2],B[2],c2);
    full_adder F4(S[3],C4,A[3],B[3],c3);
    full_adder F5(S[4],C5,A[4],B[4],C4);
    full_adder F6(S[5],C6,A[5],B[5],C5);
    full_adder F7(S[6],C7,A[6],B[6],C6);
    full_adder F8(S[7],c8,A[7],B[7],C7);
    full_adder F9(S[8],C9,A[8],B[8],C8);
    full_adder F10(S[9],c10,A[9],B[9],C9);
    full_adder F11(S[10],c11,A[10],B[10],c10);
    full_adder F12(S[11],c12,A[11],B[11],c11);
    full_adder F13(S[12],C13,A[12],B[12],c12);
    full_adder F14(S[13],C14,A[13],B[13],C13);
    full_adder F15(S[14],C15,A[14],B[14],C14);
    full_adder F16(S[15],Cout,A[15],B[14],C15);
    and g0(p0,A[0],B[0]);
    and g1(p1,A[1],B[1]);
    and g2(p2,A[2],B[2]);
    and g3(p3,A[3],B[3]);
    and g4(p4,A[4],B[4]);
    and g5(p5,A[5],B[5]);
    and g6(p6,A[6],B[6]);
    and g7(p7,A[7],B[7]);
    and g8(p8,A[8],B[8]);
    and g9(p9,A[9],B[9]);
    and g10(p10,A[10],B[10]);
    and g11(p11,A[11],B[11]);
    and g12(p12,A[12],B[12]);
    and g13(p13,A[13],B[13]);
    and g14(p14,A[14],B[14]);
    and g15(p15,A[15],B[15]);
   mux2x1 m1(cout1,c3,cout,se1);
    mux2x1 m2(cout2,c7,cout1,se2);
    mux2x1 m3(cout3,c11,cout2,se3);
   mux2x1 m4(cout4,c15,cout3,se4);
   endmodule;

Verilog Program for 32-bit Ripple Carry Adder

      module RCA32(cout,s,cin,a,b);        
           input[31:0]a;
           input[31:0]b;
            input cin;
            output[31:0]s;
            output cout;
            wire c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13,c14,c15,c16,c17,c18,c19,c20,c21,c22,c23,c24,
            c26,c27,c28,c29,c30,c31;
            full_adder a1(c1,s[0],a[0],b[0],cin);
            full_adder a2(c2,s[1],a[1],b[1],c1);
            full_adder a3(c3,s[2],a[2],b[2],c2);
            full_adder a4(c4,s[3],a[3],b[3],c3);
            full_adder a5(c5,s[4],a[4],b[4],c4);
            full_adder a6(c6,s[5],a[5],b[5],c5);
            full_adder a7(c7,s[6],a[6],b[6],c6);
            full_adder a8(c8,s[7],a[7],b[7],c7);
            full_adder a9(c9,s[8],a[8],b[8],c8);
            full_adder a10(c10,s[9],a[9],b[9],c9);
            full_adder a11(c11,s[10],a[10],b[10],c10);
            full_adder a12(c12,s[11],a[11],b[11],c11);
            full_adder a13(c13,s[12],a[12],b[12],c12);
            full_adder a14(c14,s[13],a[13],b[13],c13);
            full_adder a15(c15,s[14],a[14],b[14],c14);
            full_adder a16(c16,s[15],a[15],b[15],c15);
            full_adder a17(c17,s[16],a[16],b[16],c16);
            full_adder a18(c18,s[17],a[17],b[17],c17);
            full_adder a19(c19,s[18],a[18],b[18],c18);
            full_adder a20(c20,s[19],a[19],b[19],c19);
            full_adder a21(c21,s[20],a[20],b[20],c20);
            full_adder a22(c22,s[21],a[21],b[21],c21);
            full_adder a23(c23,s[22],a[22],b[22],c22);
            full_adder a24(c24,s[23],a[23],b[23],c23);
            full_adder a25(c25,s[24],a[24],b[24],c24);
            full_adder a26(c26,s[25],a[25],b[25],c25);
            full_adder a27(c27,s[26],a[26],b[26],c26);
            full_adder a28(c28,s[27],a[27],b[27],c27);
            full_adder a29(c29,s[28],a[28],b[28],c28);
            full_adder a30(c30,s[29],a[29],b[29],c29);
            full_adder a31(c31,s[30],a[30],b[30],c30);
endmodule;

Verilog Program for 16-bit Ripple Carry Adder

module RCA16(cout,s,cin,a,b);
           input[15:0]a;
             input[15:0]b;
           input cin;
           output[15:0]s;
           output cout;
           wire c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13,c14,c15;
           full_adder a1(c1,s[0],a[0],b[0],cin);
           full_adder a2(c2,s[1],a[1],b[1],c1);
           full_adder a3(c3,s[2],a[2],b[2],c2);
           full_adder a4(c4,s[3],a[3],b[3],c3);
           full_adder a5(c5,s[4],a[4],b[4],c4);
           full_adder a6(c6,s[5],a[5],b[5],c5);
           full_adder a7(c7,s[6],a[6],b[6],c6);
           full_adder a8(c8,s[7],a[7],b[7],c7);
           full_adder a9(c9,s[8],a[8],b[8],c8);
           full_adder a10(c10,s[9],a[9],b[9],c9);
           full_adder a11(c11,s[10],a[10],b[10],c10);
           full_adder a12(c12,s[11],a[11],b[11],c11);
           full_adder a13(c13,s[12],a[12],b[12],c12);
           full_adder a14(c14,s[13],a[13],b[13],c13);
           full_adder a15(c15,s[14],a[14],b[14],c14);
   endmodule;
          

Verilog Program for 8-bit Ripple Carry Adder

module RCA8(cout,s,cin,a,b);
    input[7:0]a;
    input[7:0]b;
    input cin;
    output[7:0]s;
    output cout;
    wire c1,c2,c3,c4,c5,c6,c7,c8;
    full_adder a1(c1,s[0],a[0],b[0],cin);
    full_adder a2(c2,s[1],a[1],b[1],c2);
    full_adder a3(c3,s[2],a[2],b[2],c3);
    full_adder a4(c4,s[3],a[3],b[3],c4);
    full_adder a5(c5,s[4],a[4],b[4],c5);
    full_adder a6(c6,s[5],a[5],b[5],c6);
    full_adder a7(c7,s[6],a[6],b[6],c7);
    full_adder a8(c8,s[7],a[7],b[7],cout);
endmodule;                                                           

Verilog Program for 4-bit Carry Select Adder

module CSA4 (COUT,S,A,B);
    output [3:0]S;
    output COUT;
    input [3:0]A,B;
    wire c1,c2,c3,P0,P1,P2,P3;
    full_adder F1(S[0],c1,A[0],B[0],1'B0);
    full_adder F2(S[1],c2,A[1],B[1],c1);
    full_adder F3(S[2],c3,A[2],B[2],c2);
    full_adder F4(S[3],COUT,A[3],B[3],c3);
    and a0(p0,a0,b0);
    and a1(p1,a1,b1);
    and a2(p2,a2,b2);
    and a3(p3,a3,b3);
    and a4(sel,p0,p1,p2,p3);
   
endmodule;

Verilog Program for 4-bit Carry look Ahead Adder

module RCA4(cout,s,cin,a,b);
    input[3:0]a;
    input[3:0]b;
    input cin;
    output[3:0]s;
    output cout;
    wire c1,c2,c3,c4;
    full_adder a1(c1,s[0],a[0],b[0],cin);
    full_adder a2(c2,s[1],a[1],b[1],c2);
    full_adder a3(c3,s[2],a[2],b[2],c3);
    full_adder a4(c4,s[3],a[3],b[3],cout);
endmodule;                                                           

Verilog Program for 16-bit Carry look Ahead Adder

module cla_16bit(a,b,cin,sum,cout);
    input [15:0]a,b;
    input cin;
    output [15:0]sum;
    output cout;
    //assign cin=1'b0;
    wire p0,p1,g0,w0;
    and (g0,a[0],b[0]);
    xor (p0,a[0],b[0]);
    and (w0,p0,cin);
    or (cout,g0,w0);
    xor (p1,a[1],b[1]);
    xor (p2,a[2],b[2]);
    xor (p3,a[3],b[3]);
    xor (p4,a[4],b[4]);
    xor (p5,a[5],b[5]);
    xor (p6,a[6],b[6]);
    xor (p7,a[7],b[7]);
    xor (p8,a[8],b[8]);
    xor (p9,a[9],b[9]);
    xor (p10,a[10],b[10]);
    xor (p11,a[11],b[11]);
    xor (p12,a[12],b[12]);
    xor (p13,a[13],b[13]);
    xor (p14,a[14],b[14]);
    xor (p15,a[15],b[15]);
    xor (sum[0],p0,cin);
    xor (sum[1],p1,c1);
    xor (sum[2],p2,c2);
    xor (sum[3],p3,c3);
    xor (sum[4],p4,c4);
    xor (sum[5],p5,c5);
    xor (sum[6],p6,c6);
    xor (sum[7],p7,c7);
    xor (sum[8],p8,c8);
    xor (sum[9],p9,c9);
    xor (sum[10],p10,c10);
    xor (sum[11],p11,c11);
    xor (sum[12],p12,c12);
    xor (sum[13],p13,c13);
    xor (sum[14],p14,c14);
    xor (sum[15],p15,cout);
endmodule;
       
   

Verilog Program for Half Adder

module half_adder (s,c,a,b);
    input a,b;
    output s,c;
    assign s=a^b;
    assign c=a&b;
 endmodule;