`timescale 1ns / 1ps

//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 16:36:25 03/19/2018
// Design Name:
// Module Name: kooge_stone_adder
// Project Name:
// Target Devices:
// Tool versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//////////////////////////////////////////////////////////////////////////////////

module ks_main(input clk,output one,output two);

wire [15:0]s;
wire co;
reg c,one,two;

always @(negedge clk)

begin
if(c == 1)
begin
if(s[0] == 0)
one <= 1;
else
one <= 0;
end

if(c == 0)
begin
if(s[0] == 0)
two <= 0;
else
two <= 1;
end

c <=~c;
end

kooge_stone_adder ks_16b(16'd10,16'd1,c,s,co,clk);
endmodule

module kooge_stone_adder(input [15:0]a1,input [15:0]b1,input cin1,output [15:0]s1,

output cout1,input clock);
wire [15:0] p,g,p1,g1,p2,g2,p3,g3,c;

wire [15:0]a,b,s;
wire cin,cout;
dff_16bit a_input(a1,clock,a);
dff_16bit b_input(b1,clock,b);
dff cin_input(cin1,clock,cin);
dff cout_output(cout,clock,cout1);
dff_16bit s_output(s,clock,s1);

//////////Preprocessing stage////////////
xor_16 xor_block1(a,b,p);
and_16 and_block1(a,b,g);
assign c[0]=g[0];
/////////Carry Generation stage//////////
////////////Stage1///////////////////////
calculate_p_g pg15_1(p[15],g[15],p[14],g[14],p1[15],g1[15]);
calculate_p_g pg14_1(p[14],g[14],p[13],g[13],p1[14],g1[14]);
calculate_p_g pg13_1(p[13],g[13],p[12],g[12],p1[13],g1[13]);
calculate_p_g pg12_1(p[12],g[12],p[11],g[11],p1[12],g1[12]);
calculate_p_g pg11_1(p[11],g[11],p[10],g[10],p1[11],g1[11]);
calculate_p_g pg10_1(p[10],g[10],p[9], g[9], p1[10],g1[10]);
calculate_p_g pg9_1( p[9], g[9], p[8], g[8], p1[9], g1[9]);
calculate_p_g pg8_1( p[8], g[8], p[7], g[7], p1[8], g1[8]);
calculate_p_g pg7_1( p[7], g[7], p[6], g[6], p1[7], g1[7]);
calculate_p_g pg6_1( p[6], g[6], p[5], g[5], p1[6], g1[6]);
calculate_p_g pg5_1( p[5], g[5], p[4], g[4], p1[5], g1[5]);
calculate_p_g pg4_1( p[4], g[4], p[3], g[3], p1[4], g1[4]);
calculate_p_g pg3_1( p[3], g[3], p[2], g[2], p1[3], g1[3]);
calculate_p_g pg2_1( p[2], g[2], p[1], g[1], p1[2], g1[2]);
calculate_p_g pg1_1( p[1], g[1], p[0], g[0], p1[1], g1[1]);
assign p1[0]=p[0];
assign g1[0]=g[0];
assign c[1] = g1[1];
/////////////////////////////////////////

////////////Stage2////////////////////////
calculate_p_g pg15_2(p1[15],g1[15],p1[13],g1[13],p2[15],g2[15]);
calculate_p_g pg14_2(p1[14],g1[14],p1[12],g1[12],p2[14],g2[14]);
calculate_p_g pg13_2(p1[13],g1[13],p1[11],g1[11],p2[13],g2[13]);
calculate_p_g pg12_2(p1[12],g1[12],p1[10],g1[10],p2[12],g2[12]);
calculate_p_g pg11_2(p1[11],g1[11],p1[9], g1[9], p2[11],g2[11]);
calculate_p_g pg10_2(p1[10],g1[10],p1[8], g1[8], p2[10],g2[10]);
calculate_p_g pg9_2( p1[9], g1[9], p1[7], g1[7], p2[9], g2[9]);
calculate_p_g pg8_2( p1[8], g1[8], p1[6], g1[6], p2[8], g2[8]);
calculate_p_g pg7_2( p1[7], g1[7], p1[5], g1[5], p2[7], g2[7]);
calculate_p_g pg6_2( p1[6], g1[6], p1[4], g1[4], p2[6], g2[6]);
calculate_p_g pg5_2( p1[5], g1[5], p1[3], g1[3], p2[5], g2[5]);
calculate_p_g pg4_2( p1[4], g1[4], p1[2], g1[2], p2[4], g2[4]);
//calculate_p_g pg3_2( p1[3], g1[3], p1[1], g1[1], p2[3], g2[3]);
assign p2[0]=p1[0];
assign p2[1]=p1[1];
assign p2[2]=p1[2];
assign p2[3]=p1[3];
assign g2[0]=g1[0];
assign g2[1]=g1[1];
assign g2[2]=g1[2];
assign g2[3]=g1[3];
assign c[2] = g1[2];
assign c[3] = g1[3];

/////////////////////////////////////////
////////////Stage3////////////////////////
calculate_p_g pg15_3(p2[15],g2[15],p2[11],g2[11],p3[15],g3[15]);
calculate_p_g pg14_3(p2[14],g2[14],p2[10],g2[10],p3[14],g3[14]);
calculate_p_g pg13_3(p2[13],g2[13],p2[9], g2[9], p3[13],g3[13]);
calculate_p_g pg12_3(p2[12],g2[12],p2[8], g2[8], p3[12],g3[12]);
calculate_p_g pg11_3(p2[11],g2[11],p2[7], g2[7], p3[11],g3[11]);
calculate_p_g pg10_3(p2[10],g2[10],p2[6], g2[6], p3[10],g3[10]);
calculate_p_g pg9_3 (p2[9], g2[9], p2[5], g2[5], p3[9], g3[9]);
calculate_p_g pg8_3 (p2[8], g2[8], p2[4], g2[4], p3[8], g3[8]);
assign p3[0]=p2[0];
assign p3[1]=p2[1];
assign p3[2]=p2[2];
assign p3[3]=p2[3];
assign p3[4]=p2[4];
assign p3[5]=p2[5];
assign p3[6]=p2[6];
assign p3[7]=p2[7];
assign g3[0]=g2[0];
assign g3[1]=g2[1];
assign g3[2]=g2[2];
assign g3[3]=g2[3];
assign g3[4]=g2[4];
assign g3[5]=g2[5];
assign g3[6]=g2[6];
assign g3[7]=g2[7];

assign c[4]=g2[4];
assign c[5]=g2[5];
assign c[6]=g2[6];
assign c[7]=g2[7];

/////////////////////////////////////////

////////////Stage3////////////////////////
assign c[8]=g3[8];
assign c[9]=g3[9];
assign c[10]=g3[10];
assign c[11]=g3[11];
assign c[12]=g3[12];
assign c[13]=g3[13];
assign c[14]=g3[14];
assign c[15]=g3[15];

////////Post Processing stage///////////

xor xor15(s[15],p3[15],c[14]);
xor xor14(s[14],p3[14],c[13]);
xor xor13(s[13],p3[13],c[12]);
xor xor12(s[12],p3[12],c[11]);
xor xor11(s[11],p3[11],c[10]);
xor xor10(s[10],p3[10],c[9]);
xor xor9 (s[9],p3[9],c[8]);
xor xor8 (s[8],p3[8],c[7]);
xor xor7 (s[7],p3[7],c[6]);
xor xor6 (s[6],p3[6],c[5]);
xor xor5 (s[5],p3[5],c[4]);
xor xor4 (s[4],p3[4],c[3]);
xor xor3 (s[3],p3[3],c[2]);
xor xor2 (s[2],p3[2],c[1]);
xor xor1 (s[1],p3[1],c[0]);
xor xor0 (s[0],p3[0],cin);

assign cout = c[15];

endmodule
module xor_16(input [15:0]a,input [15:0]b,output [15:0]p);
xor xor0(p[0],a[0],b[0]);
xor xor1(p[1],a[1],b[1]);
xor xor2(p[2],a[2],b[2]);
xor xor3(p[3],a[3],b[3]);
xor xor4(p[4],a[4],b[4]);
xor xor5(p[5],a[5],b[5]);
xor xor6(p[6],a[6],b[6]);
xor xor7(p[7],a[7],b[7]);
xor xor8(p[8],a[8],b[8]);
xor xor9(p[9],a[9],b[9]);
xor xor10(p[10],a[10],b[10]);
xor xor11(p[11],a[11],b[11]);
xor xor12(p[12],a[12],b[12]);
xor xor13(p[13],a[13],b[13]);
xor xor14(p[14],a[14],b[14]);
xor xor15(p[15],a[15],b[15]);
endmodule

module and_16(input [15:0]a,input [15:0]b,output [15:0]p);

and and0(p[0],a[0],b[0]);
and and1(p[1],a[1],b[1]);
and and2(p[2],a[2],b[2]);
and and3(p[3],a[3],b[3]);
and and4(p[4],a[4],b[4]);
and and5(p[5],a[5],b[5]);
and and6(p[6],a[6],b[6]);
and and7(p[7],a[7],b[7]);
and and8(p[8],a[8],b[8]);
and and9(p[9],a[9],b[9]);
and and10(p[10],a[10],b[10]);
and and11(p[11],a[11],b[11]);
and and12(p[12],a[12],b[12]);
and and13(p[13],a[13],b[13]);
and and14(p[14],a[14],b[14]);
and and15(p[15],a[15],b[15]);
endmodule

module calculate_p_g(input p,input g,input p_last, input g_last,output p_new,output

g_new); //Current pg,last pg,new pg
wire x;
and and1(x,g_last,p);
or or1(g_new,g,x); //G2=G1||(G0&&P1)

and and2(p_new,p,p_last); //P2=P1&&P0

endmodule