module PC(//uscite : 
	  // tutti i beta 
	  bx, by, bq, bor, boq, brdy, back,
	  // tutti gli alpha
	  akx, akq,
	  // ingressi: 
	  rdy, segno, clock);
 
   output bx, by, bq, bor, boq, brdy, back;
   output akx, akq;
   input  rdy, segno, clock;
 
 
   wire   nuovostato;
 
 
   OmegaPC ompc(bx, by, bq, bor, boq, brdy, back,
	       akx, akq,
	       rdy, segno, 
	       stato);
 
   SigmaPC sipc(nuovostato,
		stato,
		rdy, segno);
 
   registro #(1) s(stato,nuovostato,1'b1,clock);
 
 
endmodule

module OmegaPC(// tutti i beta
	       bx, by, bq, bor, boq, brdy, back,
	       // tutti gli alpha
	       akx, akq,
	       // gli ingressi dalla PO
	       rdy, segno, 
	       // stato interno 
	       stato);
 
   output bx, by, bq, bor, boq, brdy, back;
   output akx, akq;
   input  rdy, segno, stato;
 
   assign #2 bx = (rdy & (~stato)) | (~segno & stato);
   assign #2 by = (rdy & (~stato));
   assign #2 bq = (rdy & (~stato)) | (~segno & stato);
   assign #2 bor = (segno & stato);
   assign #2 boq = (segno & stato);
   assign #2 brdy = (segno & stato);
   assign #2 back = (segno & stato);
 
   assign #2 akx = (~segno & stato);
   assign #2 akq = (~segno & stato);
 
 
endmodule

module SigmaPC(output sprimo,
	       input stato,
	       input rdy, 
	       input segno);
 
   assign #2 sprimo = (~stato & rdy) | (stato & ~segno);
 
endmodule

module PO(rdy, segno, // uscite verso la PC
	  // uscite dai registri di interfaccia
	  lror, lroq, lrack,
	  // ingressi dalla PC
	  back, brdy, bx, by, bq, bor, boq, akx, akq,
	  // ingresso clock
	  clock,
	  // ingressi verso i registri di interfaccia
	  linx, liny, lrdyin
	  );
 
   parameter N = 32;
 
   output rdy;
   output segno;
   output [N-1:0] lror;
   output [N-1:0] lroq;
   output 	  lrack;
 
   input 	  back, brdy, bx, by, bq;
   input 	  bor, boq, akx, akq, clock;
 
   input [N-1:0]  linx;
   input [N-1:0]  liny;
   input 	  lrdyin;
 
 
   reg [N-1:0] 	  const0;
 
   initial
     begin
	const0 = 0;
     end
 
 
   // indicatori a transizione di livello 
   ack ackout(lrack, back, clock);
   rdy rdyin (rdy,lrdyin,brdy,clock);
 
   wire [N-1:0] 	inx2x;
   wire [N-1:0] 	iny2y;
   wire [N-1:0] 	x2ror;
   wire [N-1:0] 	q2roq;
   wire [N-1:0] 	kx2x;
   wire [N-1:0] 	y2alumeno;
   wire [N-1:0] 	aluinc2q;
   wire [N-1:0] 	rq2roq;
   wire [N-1:0] 	alumeno2kx;
   wire [N-1:0] 	aluinc2kq;
   wire [N-1:0] 	kq2q;
 
 
   // registri di ingresso
   registro #(N) rinx(inx2x,linx,1'b1,clock);
   registro #(N) riny(iny2y,liny,1'b1,clock);
 
   // registri in uscita
   registro #(N) outr(lror,x2ror,bor,clock);
   registro #(N) outq(lroq,rq2roq,boq,clock);
 
   // registri interni
   registro #(N) rx(x2ror,kx2x,bx,clock);
   registro #(N) ry(y2alumeno,iny2y,by,clock);
   registro #(N) rq(rq2roq,kq2q,bq,clock);
 
   // alu
   alumeno #(N) alu1(alumeno2kx,segno,x2ror,y2alumeno);
   aluinc  #(N) alu2(aluinc2kq,rq2roq);
 
   // commutatori
   k2 #(N) kkx(kx2x,inx2x,alumeno2kx,akx);
   k2 #(N) kkq(kq2q,const0,aluinc2kq,akq);
 
 
endmodule

module UF(lack, lor, loq,
	  clock,
	  lrdy,linx,liny);
 
   parameter N = 4;
 
   // output verso il mondo esterno
   output lack;
   output [N-1:0] lor;
   output [N-1:0] loq;
 
   // input dal mondo esterno
   input 	  clock;
   input 	  lrdy;
 
   input [N-1:0]  linx;
   input [N-1:0]  liny;
 
   // input alla PO dalla PC
   wire 	  back, brdy, bx, by, bq, bor, boq;
   wire 	  akx, akq;
 
   // input alla PC dalla PO
   wire 	  rdy, segno;
 
   PC #(4) partecontrollo(bx, by, bq, bor, boq, brdy, back,
			  akx, akq,
			  rdy, segno, clock);
 
   PO #(4) parteoperativa(rdy, segno,
			  lor, loq, lack,
			  back, brdy, bx, by, bq, bor, boq,
			  akx, akq,
			  clock,
			  linx, liny, lrdy);
 
endmodule