module multiplier(Ck, NRESET, A, B, C, Start, Rdy);

  input [7:0] A, B;
  input Start;
  input Ck, NRESET;
  output [15:0] C;
  output Rdy;

  wire reg_inputs, reg_outputs;

  ///////////////////////////////
  //// valor de A registrado ////
  ///////////////////////////////
  reg [7:0] A_reg;
  always@(posedge Ck or negedge NRESET)
    if (~NRESET)
      A_reg <= 0;
    else if (reg_inputs)
      A_reg <= A;

  ////////////////////
  //// Acumulador ////
  ////////////////////
  reg [15:0] Aux_reg;
  wire Clr_aux;
  always@(posedge Ck or negedge NRESET)
    if (~NRESET)
      Aux_reg <= 0;
    else if (Clr_aux)
      Aux_reg <= 0;
    else
      Aux_reg <= Aux_reg + A_reg;

  ///////////////////////////////////////////
  //// Contador (registra el valor de B) ////
  ///////////////////////////////////////////
  reg [7:0] counter;
  always@(posedge Ck or negedge NRESET)
    if (~NRESET)
      counter <= 0;
    else if (reg_inputs)
      counter <= B;
    else
      counter <= counter -1;

  /////////////////////////////////
  //// Instanciación de la FSM ////
  /////////////////////////////////
  wire A_eq_Z = !A; // Señales a proporcionar
  wire B_eq_Z = !B;
  wire count_eq_Z = !counter;

  wire [1:0] state;
  FSM fsm(.clock(Ck),
          .reset(~NRESET), // Asume un reset a nivel alto, por lo tanto, invertimos la señal.
          .in({Start, A_eq_Z, B_eq_Z, count_eq_Z}), // Las señales aparecen en el orden introducido inicialmente
          .state(state), // Estados como salidas, aunque no sean necesarios en este caso.
          .moore({Clr_aux, Rdy, reg_inputs, reg_outputs}) // Lo mismo ocurre para las salidas.
  );
  /////////////////////////////
  //// Salidas registradas ////
  /////////////////////////////
  reg [15:0] C;

  always@(posedge Ck or negedge NRESET)
    if (~NRESET)
      C <= 0;
    else if (reg_outputs)
      C <= Aux_reg;

endmodule