www.pudn.com > x86.rar > division64.v, change:2007-12-05,size:19085b


module division64(dividend, divisor, divOut, signed1);
input [63:0]dividend;
input [63:0] divisor;
input signed1;
output [127:0]divOut;
wire [127:0]divOut;

wire [128:0]shiftIn;
wire [128:0] shiftIn1, shiftIn2, shiftIn3, shiftIn4;
wire [128:0] shiftIn5, shiftIn6, shiftIn7, shiftIn8;
wire [128:0] shiftIn9, shiftIn10, shiftIn11, shiftIn12;
wire [128:0] shiftIn13, shiftIn14, shiftIn15, shiftIn16;
wire [128:0] shiftIn17, shiftIn18, shiftIn19, shiftIn20;
wire [128:0] shiftIn21, shiftIn22, shiftIn23, shiftIn24;
wire [128:0] shiftIn25, shiftIn26, shiftIn27, shiftIn28;
wire [128:0] shiftIn29, shiftIn30, shiftIn31, shiftIn32;
wire [128:0] shiftIn33, shiftIn34, shiftIn35, shiftIn36;
wire [128:0] shiftIn37, shiftIn38, shiftIn39, shiftIn40;
wire [128:0] shiftIn41, shiftIn42, shiftIn43, shiftIn44;
wire [128:0] shiftIn45, shiftIn46, shiftIn47, shiftIn48;
wire [128:0] shiftIn49, shiftIn50, shiftIn51, shiftIn52;
wire [128:0] shiftIn53, shiftIn54, shiftIn55, shiftIn56;
wire [128:0] shiftIn57, shiftIn58, shiftIn59, shiftIn60;
wire [128:0] shiftIn61, shiftIn62, shiftIn63, shiftIn64;

wire [64:0] B;

wire [63:0] twosOut, twosOut1, twosOut2;
wire [63:0] twosOut64;

wire [128:0] shiftOut;
wire [128:0] shiftOut1, shiftOut2, shiftOut3, shiftOut4;
wire [128:0] shiftOut5, shiftOut6, shiftOut7, shiftOut8;
wire [128:0] shiftOut9, shiftOut10, shiftOut11, shiftOut12;
wire [128:0] shiftOut13, shiftOut14, shiftOut15, shiftOut16;
wire [128:0] shiftOut17, shiftOut18, shiftOut19, shiftOut20;
wire [128:0] shiftOut21, shiftOut22, shiftOut23, shiftOut24;
wire [128:0] shiftOut25, shiftOut26, shiftOut27, shiftOut28;
wire [128:0] shiftOut29, shiftOut30, shiftOut31, shiftOut32;
wire [128:0] shiftOut33, shiftOut34, shiftOut35, shiftOut36;
wire [128:0] shiftOut37, shiftOut38, shiftOut39, shiftOut40;
wire [128:0] shiftOut41, shiftOut42, shiftOut43, shiftOut44;
wire [128:0] shiftOut45, shiftOut46, shiftOut47, shiftOut48;
wire [128:0] shiftOut49, shiftOut50, shiftOut51, shiftOut52;
wire [128:0] shiftOut53, shiftOut54, shiftOut55, shiftOut56;
wire [128:0] shiftOut57, shiftOut58, shiftOut59, shiftOut60;
wire [128:0] shiftOut61, shiftOut62, shiftOut63, shiftOut64;

wire [64:0] claOut1, claOut2, claOut3, claOut4, claOut5, claOut6, claOut7, claOut8;
wire [64:0] claOut9, claOut10, claOut11, claOut12, claOut13, claOut14, claOut15, claOut16;
wire [64:0] claOut17, claOut18, claOut19, claOut20, claOut21, claOut22, claOut23, claOut24;
wire [64:0] claOut25, claOut26, claOut27, claOut28, claOut29, claOut30, claOut31, claOut32;
wire [64:0] claOut33, claOut34, claOut35, claOut36, claOut37, claOut38, claOut39, claOut40;
wire [64:0] claOut41, claOut42, claOut43, claOut44, claOut45, claOut46, claOut47, claOut48;
wire [64:0] claOut49, claOut50, claOut51, claOut52, claOut53, claOut54, claOut55, claOut56;
wire [64:0] claOut57, claOut58, claOut59, claOut60, claOut61, claOut62, claOut63, claOut64;

wire [64:0] carryOut1, carryOut2, carryOut3, carryOut4, carryOut5, carryOut6, carryOut7, carryOut8;
wire [64:0] carryOut9, carryOut10, carryOut11, carryOut12, carryOut13, carryOut14, carryOut15, carryOut16;
wire [64:0] carryOut17, carryOut18, carryOut19, carryOut20, carryOut21, carryOut22, carryOut23, carryOut24;
wire [64:0] carryOut25, carryOut26, carryOut27, carryOut28, carryOut29, carryOut30, carryOut31, carryOut32;
wire [64:0] carryOut33, carryOut34, carryOut35, carryOut36, carryOut37, carryOut38, carryOut39, carryOut40;
wire [64:0] carryOut41, carryOut42, carryOut43, carryOut44, carryOut45, carryOut46, carryOut47, carryOut48;
wire [64:0] carryOut49, carryOut50, carryOut51, carryOut52, carryOut53, carryOut54, carryOut55, carryOut56;
wire [64:0] carryOut57, carryOut58, carryOut59, carryOut60, carryOut61, carryOut62, carryOut63, carryOut64;

twosComp64   twosCompInst1(twosOut, divisor[63:0]);

cla65Bit cla65BitInst1( claOut1, carryOut1 , shiftOut[128:64], B, 1'b0);
cla65Bit cla65BitInst2( claOut2, carryOut2 , shiftOut1[128:64], B, 1'b0);
cla65Bit cla65BitInst3( claOut3, carryOut3 , shiftOut2[128:64], B, 1'b0);
cla65Bit cla65BitInst4( claOut4, carryOut4 , shiftOut3[128:64], B, 1'b0);
cla65Bit cla65BitInst5( claOut5, carryOut5 , shiftOut4[128:64], B, 1'b0);
cla65Bit cla65BitInst6( claOut6, carryOut6 , shiftOut5[128:64], B, 1'b0);
cla65Bit cla65BitInst7( claOut7, carryOut7 , shiftOut6[128:64], B, 1'b0);
cla65Bit cla65BitInst8( claOut8, carryOut8 , shiftOut7[128:64], B, 1'b0);
cla65Bit cla65BitInst9( claOut9, carryOut9 , shiftOut8[128:64], B, 1'b0);
cla65Bit cla65BitInst10( claOut10, carryOut10 , shiftOut9[128:64], B, 1'b0);
cla65Bit cla65BitInst11( claOut11, carryOut11 , shiftOut10[128:64], B, 1'b0);
cla65Bit cla65BitInst12( claOut12, carryOut12 , shiftOut11[128:64], B, 1'b0);
cla65Bit cla65BitInst13( claOut13, carryOut13 , shiftOut12[128:64], B, 1'b0);
cla65Bit cla65BitInst14( claOut14, carryOut14 , shiftOut13[128:64], B, 1'b0);
cla65Bit cla65BitInst15( claOut15, carryOut15 , shiftOut14[128:64], B, 1'b0);
cla65Bit cla65BitInst16( claOut16, carryOut16 , shiftOut15[128:64], B, 1'b0);
cla65Bit cla65BitInst17( claOut17, carryOut17 , shiftOut16[128:64], B, 1'b0);
cla65Bit cla65BitInst18( claOut18, carryOut18 , shiftOut17[128:64], B, 1'b0);
cla65Bit cla65BitInst19( claOut19, carryOut19 , shiftOut18[128:64], B, 1'b0);
cla65Bit cla65BitInst20( claOut20, carryOut20 , shiftOut19[128:64], B, 1'b0);
cla65Bit cla65BitInst21( claOut21, carryOut21 , shiftOut20[128:64], B, 1'b0);
cla65Bit cla65BitInst22( claOut22, carryOut22 , shiftOut21[128:64], B, 1'b0);
cla65Bit cla65BitInst23( claOut23, carryOut23 , shiftOut22[128:64], B, 1'b0);
cla65Bit cla65BitInst24( claOut24, carryOut24 , shiftOut23[128:64], B, 1'b0);
cla65Bit cla65BitInst25( claOut25, carryOut25 , shiftOut24[128:64], B, 1'b0);
cla65Bit cla65BitInst26( claOut26, carryOut26 , shiftOut25[128:64], B, 1'b0);
cla65Bit cla65BitInst27( claOut27, carryOut27 , shiftOut26[128:64], B, 1'b0);
cla65Bit cla65BitInst28( claOut28, carryOut28 , shiftOut27[128:64], B, 1'b0);
cla65Bit cla65BitInst29( claOut29, carryOut29 , shiftOut28[128:64], B, 1'b0);
cla65Bit cla65BitInst30( claOut30, carryOut30 , shiftOut29[128:64], B, 1'b0);
cla65Bit cla65BitInst31( claOut31, carryOut31 , shiftOut30[128:64], B, 1'b0);
cla65Bit cla65BitInst32( claOut32, carryOut32 , shiftOut31[128:64], B, 1'b0);
cla65Bit cla65BitInst33( claOut33, carryOut33 , shiftOut32[128:64], B, 1'b0);
cla65Bit cla65BitInst34( claOut34, carryOut34 , shiftOut33[128:64], B, 1'b0);
cla65Bit cla65BitInst35( claOut35, carryOut35 , shiftOut34[128:64], B, 1'b0);
cla65Bit cla65BitInst36( claOut36, carryOut36 , shiftOut35[128:64], B, 1'b0);
cla65Bit cla65BitInst37( claOut37, carryOut37 , shiftOut36[128:64], B, 1'b0);
cla65Bit cla65BitInst38( claOut38, carryOut38 , shiftOut37[128:64], B, 1'b0);
cla65Bit cla65BitInst39( claOut39, carryOut39 , shiftOut38[128:64], B, 1'b0);
cla65Bit cla65BitInst40( claOut40, carryOut40 , shiftOut39[128:64], B, 1'b0);
cla65Bit cla65BitInst41( claOut41, carryOut41 , shiftOut40[128:64], B, 1'b0);
cla65Bit cla65BitInst42( claOut42, carryOut42 , shiftOut41[128:64], B, 1'b0);
cla65Bit cla65BitInst43( claOut43, carryOut43 , shiftOut42[128:64], B, 1'b0);
cla65Bit cla65BitInst44( claOut44, carryOut44 , shiftOut43[128:64], B, 1'b0);
cla65Bit cla65BitInst45( claOut45, carryOut45, shiftOut44[128:64], B, 1'b0);
cla65Bit cla65BitInst46( claOut46, carryOut46 , shiftOut45[128:64], B, 1'b0);
cla65Bit cla65BitInst47( claOut47, carryOut47 , shiftOut46[128:64], B, 1'b0);
cla65Bit cla65BitInst48( claOut48, carryOut48 , shiftOut47[128:64], B, 1'b0);
cla65Bit cla65BitInst49( claOut49, carryOut49 , shiftOut48[128:64], B, 1'b0);
cla65Bit cla65BitInst50( claOut50, carryOut50 , shiftOut49[128:64], B, 1'b0);
cla65Bit cla65BitInst51( claOut51, carryOut51 , shiftOut50[128:64], B, 1'b0);
cla65Bit cla65BitInst52( claOut52, carryOut52 , shiftOut51[128:64], B, 1'b0);
cla65Bit cla65BitInst53( claOut53, carryOut53 , shiftOut52[128:64], B, 1'b0);
cla65Bit cla65BitInst54( claOut54, carryOut54 , shiftOut53[128:64], B, 1'b0);
cla65Bit cla65BitInst55( claOut55, carryOut55 , shiftOut54[128:64], B, 1'b0);
cla65Bit cla65BitInst56( claOut56, carryOut56 , shiftOut55[128:64], B, 1'b0);
cla65Bit cla65BitInst57( claOut57, carryOut57 , shiftOut56[128:64], B, 1'b0);
cla65Bit cla65BitInst58( claOut58, carryOut58 , shiftOut57[128:64], B, 1'b0);
cla65Bit cla65BitInst59( claOut59, carryOut59 , shiftOut58[128:64], B, 1'b0);
cla65Bit cla65BitInst60( claOut60, carryOut60 , shiftOut59[128:64], B, 1'b0);
cla65Bit cla65BitInst61( claOut61, carryOut61 , shiftOut60[128:64], B, 1'b0);
cla65Bit cla65BitInst62( claOut62, carryOut62 , shiftOut61[128:64], B, 1'b0);
cla65Bit cla65BitInst63( claOut63, carryOut63 , shiftOut62[128:64], B, 1'b0);
cla65Bit cla65BitInst64( claOut64, carryOut64 , shiftOut63[128:64], B, 1'b0);


shifter129Bit shifter129BitInst0(shiftOut, shiftIn, 1'b1);
shifter129Bit shifter129BitInst1(shiftOut1, shiftIn1, 1'b1);
shifter129Bit shifter129BitInst2(shiftOut2, shiftIn2, 1'b1);
shifter129Bit shifter129BitInst3(shiftOut3, shiftIn3, 1'b1);
shifter129Bit shifter129BitInst4(shiftOut4, shiftIn4, 1'b1);
shifter129Bit shifter129BitInst5(shiftOut5, shiftIn5, 1'b1);
shifter129Bit shifter129BitInst6(shiftOut6, shiftIn6, 1'b1);
shifter129Bit shifter129BitInst7(shiftOut7, shiftIn7, 1'b1);
shifter129Bit shifter129BitInst8(shiftOut8, shiftIn8, 1'b1);
shifter129Bit shifter129BitInst9(shiftOut9, shiftIn9, 1'b1);
shifter129Bit shifter129BitInst10(shiftOut10, shiftIn10, 1'b1);
shifter129Bit shifter129BitInst11(shiftOut11, shiftIn11, 1'b1);
shifter129Bit shifter129BitInst12(shiftOut12, shiftIn12, 1'b1);
shifter129Bit shifter129BitInst13(shiftOut13, shiftIn13, 1'b1);
shifter129Bit shifter129BitInst14(shiftOut14, shiftIn14, 1'b1);
shifter129Bit shifter129BitInst15(shiftOut15, shiftIn15, 1'b1);
shifter129Bit shifter129BitInst16(shiftOut16, shiftIn16, 1'b1);
shifter129Bit shifter129BitInst17(shiftOut17, shiftIn17, 1'b1);
shifter129Bit shifter129BitInst18(shiftOut18, shiftIn18, 1'b1);
shifter129Bit shifter129BitInst19(shiftOut19, shiftIn19, 1'b1);
shifter129Bit shifter129BitInst20(shiftOut20, shiftIn20, 1'b1);
shifter129Bit shifter129BitInst21(shiftOut21, shiftIn21, 1'b1);
shifter129Bit shifter129BitInst22(shiftOut22, shiftIn22, 1'b1);
shifter129Bit shifter129BitInst23(shiftOut23, shiftIn23, 1'b1);
shifter129Bit shifter129BitInst24(shiftOut24, shiftIn24, 1'b1);
shifter129Bit shifter129BitInst25(shiftOut25, shiftIn25, 1'b1);
shifter129Bit shifter129BitInst26(shiftOut26, shiftIn26, 1'b1);
shifter129Bit shifter129BitInst27(shiftOut27, shiftIn27, 1'b1);
shifter129Bit shifter129BitInst28(shiftOut28, shiftIn28, 1'b1);
shifter129Bit shifter129BitInst29(shiftOut29, shiftIn29, 1'b1);
shifter129Bit shifter129BitInst30(shiftOut30, shiftIn30, 1'b1);
shifter129Bit shifter129BitInst31(shiftOut31, shiftIn31, 1'b1);
shifter129Bit shifter129BitInst32(shiftOut32, shiftIn32, 1'b1);
shifter129Bit shifter129BitInst33(shiftOut33, shiftIn33, 1'b1);
shifter129Bit shifter129BitInst34(shiftOut34, shiftIn34, 1'b1);
shifter129Bit shifter129BitInst35(shiftOut35, shiftIn35, 1'b1);
shifter129Bit shifter129BitInst36(shiftOut36, shiftIn36, 1'b1);
shifter129Bit shifter129BitInst37(shiftOut37, shiftIn37, 1'b1);
shifter129Bit shifter129BitInst38(shiftOut38, shiftIn38, 1'b1);
shifter129Bit shifter129BitInst39(shiftOut39, shiftIn39, 1'b1);
shifter129Bit shifter129BitInst40(shiftOut40, shiftIn40, 1'b1);
shifter129Bit shifter129BitInst41(shiftOut41, shiftIn41, 1'b1);
shifter129Bit shifter129BitInst42(shiftOut42, shiftIn42, 1'b1);
shifter129Bit shifter129BitInst43(shiftOut43, shiftIn43, 1'b1);
shifter129Bit shifter129BitInst44(shiftOut44, shiftIn44, 1'b1);
shifter129Bit shifter129BitInst45(shiftOut45, shiftIn45, 1'b1);
shifter129Bit shifter129BitInst46(shiftOut46, shiftIn46, 1'b1);
shifter129Bit shifter129BitInst47(shiftOut47, shiftIn47, 1'b1);
shifter129Bit shifter129BitInst48(shiftOut48, shiftIn48, 1'b1);
shifter129Bit shifter129BitInst49(shiftOut49, shiftIn49, 1'b1);
shifter129Bit shifter129BitInst50(shiftOut50, shiftIn50, 1'b1);
shifter129Bit shifter129BitInst51(shiftOut51, shiftIn51, 1'b1);
shifter129Bit shifter129BitInst52(shiftOut52, shiftIn52, 1'b1);
shifter129Bit shifter129BitInst53(shiftOut53, shiftIn53, 1'b1);
shifter129Bit shifter129BitInst54(shiftOut54, shiftIn54, 1'b1);
shifter129Bit shifter129BitInst55(shiftOut55, shiftIn55, 1'b1);
shifter129Bit shifter129BitInst56(shiftOut56, shiftIn56, 1'b1);
shifter129Bit shifter129BitInst57(shiftOut57, shiftIn57, 1'b1);
shifter129Bit shifter129BitInst58(shiftOut58, shiftIn58, 1'b1);
shifter129Bit shifter129BitInst59(shiftOut59, shiftIn59, 1'b1);
shifter129Bit shifter129BitInst60(shiftOut60, shiftIn60, 1'b1);
shifter129Bit shifter129BitInst61(shiftOut61, shiftIn61, 1'b1);
shifter129Bit shifter129BitInst62(shiftOut62, shiftIn62, 1'b1);
shifter129Bit shifter129BitInst63(shiftOut63, shiftIn63, 1'b1);
shifter129Bit shifter129BitInst64(shiftOut64, shiftIn64, 1'b1);
shifter129Bit shifter129BitInst65(, shiftOut64, 1'b0);

assign  B[63:0]       = (signed1 == 1'b0) ? twosOut : ( divisor[63] == 1'b1 ? divisor: twosOut);
assign  B[64]         = 1'b1;
assign  shiftIn ={ 2'b0,dividend,63'b0 };



assign shiftIn1  = (claOut1[64]  )? shiftOut   : {claOut1,shiftOut[63:1],1'b1};
assign shiftIn2  = (claOut2[64]  )? shiftOut1  : {claOut2,shiftOut1[63:1],1'b1};
assign shiftIn3  = (claOut3[64]  )? shiftOut2  : {claOut3,shiftOut2[63:1],1'b1};
assign shiftIn4  = (claOut4[64]  )? shiftOut3  : {claOut4,shiftOut3[63:1],1'b1};
assign shiftIn5  = (claOut5[64]  )? shiftOut4  : {claOut5,shiftOut4[63:1],1'b1};
assign shiftIn6  = (claOut6[64]  )? shiftOut5  : {claOut6,shiftOut5[63:1],1'b1};
assign shiftIn7  = (claOut7[64]  )? shiftOut6  : {claOut7,shiftOut6[63:1],1'b1};
assign shiftIn8  = (claOut8[64]  )? shiftOut7  : {claOut8,shiftOut7[63:1],1'b1};
assign shiftIn9  = (claOut9[64]  )? shiftOut8  : {claOut9,shiftOut8[63:1],1'b1};
assign shiftIn10 = (claOut10[64] )? shiftOut9  : {claOut10,shiftOut9[63:1],1'b1};
assign shiftIn11 = (claOut11[64] )? shiftOut10 : {claOut11,shiftOut10[63:1],1'b1};
assign shiftIn12 = (claOut12[64] )? shiftOut11 : {claOut12,shiftOut11[63:1],1'b1};
assign shiftIn13 = (claOut13[64] )? shiftOut12 : {claOut13,shiftOut12[63:1],1'b1};
assign shiftIn14 = (claOut14[64] )? shiftOut13 : {claOut14,shiftOut13[63:1],1'b1};
assign shiftIn15 = (claOut15[64] )? shiftOut14 : {claOut15,shiftOut14[63:1],1'b1};
assign shiftIn16 = (claOut16[64] )? shiftOut15 : {claOut16,shiftOut15[63:1],1'b1};
assign shiftIn17 = (claOut17[64] )? shiftOut16 : {claOut17,shiftOut16[63:1],1'b1};
assign shiftIn18 = (claOut18[64] )? shiftOut17 : {claOut18,shiftOut17[63:1],1'b1};
assign shiftIn19 = (claOut19[64] )? shiftOut18 : {claOut19,shiftOut18[63:1],1'b1};
assign shiftIn20 = (claOut20[64] )? shiftOut19 : {claOut20,shiftOut19[63:1],1'b1};
assign shiftIn21 = (claOut21[64] )? shiftOut20 : {claOut21,shiftOut20[63:1],1'b1};
assign shiftIn22 = (claOut22[64] )? shiftOut21 : {claOut22,shiftOut21[63:1],1'b1};
assign shiftIn23 = (claOut23[64] )? shiftOut22 : {claOut23,shiftOut22[63:1],1'b1};
assign shiftIn24 = (claOut24[64] )? shiftOut23 : {claOut24,shiftOut23[63:1],1'b1};
assign shiftIn25 = (claOut25[64] )? shiftOut24 : {claOut25,shiftOut24[63:1],1'b1};
assign shiftIn26 = (claOut26[64] )? shiftOut25 : {claOut26,shiftOut25[63:1],1'b1};
assign shiftIn27 = (claOut27[64] )? shiftOut26 : {claOut27,shiftOut26[63:1],1'b1};
assign shiftIn28 = (claOut28[64] )? shiftOut27 : {claOut28,shiftOut27[63:1],1'b1};
assign shiftIn29 = (claOut29[64] )? shiftOut28 : {claOut29,shiftOut28[63:1],1'b1};
assign shiftIn30 = (claOut30[64] )? shiftOut29 : {claOut30,shiftOut29[63:1],1'b1};
assign shiftIn31 = (claOut31[64] )? shiftOut30 : {claOut31,shiftOut30[63:1],1'b1};
assign shiftIn32 = (claOut32[64] )? shiftOut31 : {claOut32,shiftOut31[63:1],1'b1};
assign shiftIn33 = (claOut33[64] )? shiftOut32 : {claOut33,shiftOut32[63:1],1'b1};
assign shiftIn34 = (claOut34[64] )? shiftOut33 : {claOut34,shiftOut33[63:1],1'b1};
assign shiftIn35 = (claOut35[64] )? shiftOut34 : {claOut35,shiftOut34[63:1],1'b1};
assign shiftIn36 = (claOut36[64] )? shiftOut35 : {claOut36,shiftOut35[63:1],1'b1};
assign shiftIn37 = (claOut37[64] )? shiftOut36 : {claOut37,shiftOut36[63:1],1'b1};
assign shiftIn38 = (claOut38[64] )? shiftOut37 : {claOut38,shiftOut37[63:1],1'b1};
assign shiftIn39 = (claOut39[64] )? shiftOut38 : {claOut39,shiftOut38[63:1],1'b1};
assign shiftIn40 = (claOut40[64] )? shiftOut39 : {claOut40,shiftOut39[63:1],1'b1};
assign shiftIn41 = (claOut41[64] )? shiftOut40 : {claOut41,shiftOut40[63:1],1'b1};
assign shiftIn42 = (claOut42[64] )? shiftOut41 : {claOut42,shiftOut41[63:1],1'b1};
assign shiftIn43 = (claOut43[64] )? shiftOut42 : {claOut43,shiftOut42[63:1],1'b1};
assign shiftIn44 = (claOut44[64] )? shiftOut43 : {claOut44,shiftOut43[63:1],1'b1};
assign shiftIn45 = (claOut45[64] )? shiftOut44 : {claOut45,shiftOut44[63:1],1'b1};
assign shiftIn46 = (claOut46[64] )? shiftOut45 : {claOut46,shiftOut45[63:1],1'b1};
assign shiftIn47 = (claOut47[64] )? shiftOut46 : {claOut47,shiftOut46[63:1],1'b1};
assign shiftIn48 = (claOut48[64] )? shiftOut47 : {claOut48,shiftOut47[63:1],1'b1};
assign shiftIn49 = (claOut49[64] )? shiftOut48 : {claOut49,shiftOut48[63:1],1'b1};
assign shiftIn50 = (claOut50[64] )? shiftOut49 : {claOut50,shiftOut49[63:1],1'b1};
assign shiftIn51 = (claOut51[64] )? shiftOut50 : {claOut51,shiftOut50[63:1],1'b1};
assign shiftIn52 = (claOut52[64] )? shiftOut51 : {claOut52,shiftOut51[63:1],1'b1};
assign shiftIn53 = (claOut53[64] )? shiftOut52 : {claOut53,shiftOut52[63:1],1'b1};
assign shiftIn54 = (claOut54[64] )? shiftOut53 : {claOut54,shiftOut53[63:1],1'b1};
assign shiftIn55 = (claOut55[64] )? shiftOut54 : {claOut55,shiftOut54[63:1],1'b1};
assign shiftIn56 = (claOut56[64] )? shiftOut55 : {claOut56,shiftOut55[63:1],1'b1};
assign shiftIn57 = (claOut57[64] )? shiftOut56 : {claOut57,shiftOut56[63:1],1'b1};
assign shiftIn58 = (claOut58[64] )? shiftOut57 : {claOut58,shiftOut57[63:1],1'b1};
assign shiftIn59 = (claOut59[64] )? shiftOut58 : {claOut59,shiftOut58[63:1],1'b1};
assign shiftIn60 = (claOut60[64] )? shiftOut59 : {claOut60,shiftOut59[63:1],1'b1};
assign shiftIn61 = (claOut61[64] )? shiftOut60 : {claOut61,shiftOut60[63:1],1'b1};
assign shiftIn62 = (claOut62[64] )? shiftOut61 : {claOut62,shiftOut61[63:1],1'b1};
assign shiftIn63 = (claOut63[64] )? shiftOut62 : {claOut63,shiftOut62[63:1],1'b1};
assign shiftIn64 = (claOut64[64] )? shiftOut63 : {claOut64,shiftOut63[63:1],1'b1};

assign divOut[63:0]  =  shiftIn64[127:64];
assign divOut[127:64] = shiftIn64[63:0];



endmodule

module shifter129Bit(shiftOut, shiftIn, direction);
input [128:0]shiftIn;
input direction;
output [128:0] shiftOut;
assign shiftOut = (direction)? ({shiftIn[127:0], 1'b0}):
                         ({1'b0, shiftIn[128:1]});
endmodule


module cla65Bit(claOut,carryOut,in1,in2,carry);
input [64:0] in1,in2;
input carry;
output [64:0] claOut,carryOut;
cla64Bit cla32BitInst(claOut[63:0],carryOut[63:0],in1[63:0],in2[63:0],carry);
assign claOut[64] = in1[64] ^ in2[64] ^ carryOut[63];
assign carryOut[64] = ((in1[64] & in2[64]) | (in2[64] & carryOut[64]) | (in1[64] & carryOut[63]));
endmodule