begin
                  {overflow,underflow,result} = LogicShift(data,distance,direction);
          end
        else if (lpm_shifttype == "ARITHMETIC")
          begin
                    {overflow,underflow,result} = ArithShift(data,distance,direction);
          end
        else if (lpm_shifttype == "ROTATE")
          begin
                    result = RotateShift(data, distance, direction) ;
  		    overflow = 1'b0;
  		    underflow = 1'b0;
          end
        else
          begin
                    result = 'bx ;
  		    overflow = 1'b0;
  		    underflow = 1'b0;
          end
 
    end

endmodule // lpm_clshift

module lpm_compare (  alb, aeb, agb, aleb, aneb, ageb, dataa, datab, clock, aclr ) ;


  parameter lpm_type = "lpm_compare" ;
  parameter lpm_width = 1 ;
  parameter lpm_pipeline = 0 ;
  parameter lpm_representation = "UNSIGNED" ;

  input  [lpm_width-1:0] dataa, datab ;
  input  clock ;
  input  aclr ;
  output alb, aeb, agb, aleb, aneb, ageb ;

  reg    tmp_alb, tmp_aeb, tmp_agb ;
  reg    tmp_aleb, tmp_aneb, tmp_ageb ;
  reg    [lpm_pipeline:0] tmp_alb2, tmp_aeb2, tmp_agb2 ;
  reg    [lpm_pipeline:0] tmp_aleb2, tmp_aneb2, tmp_ageb2 ;
  reg    [lpm_width-1:0] a_int;
  integer i, j, k, l, m, n, o, p, u, dataa_int, datab_int;

  always @( dataa or datab)
    begin
  		if (lpm_representation == "UNSIGNED") 
  	    	    begin
  			dataa_int = dataa[lpm_width-1:0];
  			datab_int = datab[lpm_width-1:0];
  	    	    end
  		else
  		if (lpm_representation == "SIGNED")
  		    begin
			if ( dataa[lpm_width-1] == 1)
	    		begin
				a_int = 0;
				for(i = 0; i < lpm_width - 1; i = i + 1)
	                		a_int[i] = dataa[i] ^ 1;
				dataa_int = (a_int + 1) * (-1) ;
			end
			else dataa_int = dataa[lpm_width-1:0];

			if ( datab[lpm_width-1] == 1)
	    		begin
				a_int = 0;
				for(j = 0; j < lpm_width - 1; j = j + 1)
	                		a_int[j] = datab[j] ^ 1;
				datab_int = (a_int + 1) * (-1) ;
			end
			else datab_int = datab[lpm_width-1:0];
		    end

		tmp_alb = (dataa_int < datab_int);
		tmp_aeb = (dataa_int == datab_int);
		tmp_agb = (dataa_int > datab_int);
		tmp_aleb = (dataa_int <= datab_int);
		tmp_aneb = (dataa_int != datab_int);
		tmp_ageb = (dataa_int >= datab_int);
    end

  always @( posedge clock or posedge aclr)
    begin
        if (aclr)
            begin 
        	for(u = 0; u <= lpm_pipeline; u = u +1)
		begin
            		tmp_aeb2[u] = 'b0 ;
            		tmp_agb2[u] = 'b0 ;
            		tmp_alb2[u] = 'b0 ;
            		tmp_aleb2[u] = 'b0 ;
            		tmp_aneb2[u] = 'b0 ;
            		tmp_ageb2[u] = 'b0 ;
		end
            end
	else
        begin
                // Assign results to registers
                tmp_alb2[lpm_pipeline] = tmp_alb ;
                tmp_aeb2[lpm_pipeline] = tmp_aeb ;
                tmp_agb2[lpm_pipeline] = tmp_agb ;
                tmp_aleb2[lpm_pipeline] = tmp_aleb ;
                tmp_aneb2[lpm_pipeline] = tmp_aneb ;
                tmp_ageb2[lpm_pipeline] = tmp_ageb ;

        	for(k = 0; k < lpm_pipeline; k = k +1)
            		tmp_alb2[k] = tmp_alb2[k+1] ;
        	for(l = 0; l < lpm_pipeline; l = l +1)
            		tmp_aeb2[l] = tmp_aeb2[l+1] ;
        	for(m = 0; m < lpm_pipeline; m = m +1)
            		tmp_agb2[m] = tmp_agb2[m+1] ;
        	for(n = 0; n < lpm_pipeline; n = n +1)
            		tmp_aleb2[n] = tmp_aleb2[n+1] ;
        	for(o = 0; o < lpm_pipeline; o = o +1)
            		tmp_aneb2[o] = tmp_aneb2[o+1] ;
        	for(p = 0; p < lpm_pipeline; p = p +1)
            		tmp_ageb2[p] = tmp_ageb2[p+1] ;
	end
    end

  assign alb = (lpm_pipeline > 0) ? tmp_alb2[0] : tmp_alb;
  assign aeb = (lpm_pipeline > 0) ? tmp_aeb2[0] : tmp_aeb;
  assign agb = (lpm_pipeline > 0) ? tmp_agb2[0] : tmp_agb;
  assign aleb = (lpm_pipeline > 0) ? tmp_aleb2[0] : tmp_aleb;
  assign aneb = (lpm_pipeline > 0) ? tmp_aneb2[0] : tmp_aneb;
  assign ageb = (lpm_pipeline > 0) ? tmp_ageb2[0] : tmp_ageb;

endmodule // lpm_compare

module lpm_constant ( result ) ;

  parameter lpm_type = "lpm_constant" ;
  parameter lpm_width = 1 ;
  parameter lpm_cvalue = 0 ;
  parameter lpm_strength = "UNUSED";

  output [lpm_width-1:0] result ;

  assign result = lpm_cvalue ;

endmodule // lpm_constant


module lpm_counter ( q, eq, 
        data, clock,
        clk_en, cnt_en, updown,
        aset, aclr, aload, 
        sset, sclr, sload) ;

  parameter lpm_type	 = "lpm_counter";
  parameter lpm_width    = 1 ;
  parameter lpm_modulus  = 1<<lpm_width ;
  parameter lpm_avalue   = "UNUSED" ;
  parameter lpm_svalue   = "UNUSED" ;
  parameter lpm_pvalue   = "UNUSED" ;
  parameter lpm_direction  = "UNUSED" ;

  output [lpm_width-1:0] q ;
  output [lpm_modulus-1:0] eq ;
  input  [lpm_width-1:0] data ;
  input  clock, clk_en, cnt_en, updown ;
  input  aset, aclr, aload ;
  input  sset, sclr, sload ;

  reg  [lpm_width-1:0] tmp_count ;
  reg  [lpm_width-1:0] re_start ;
  integer up_limit ;

//---------------------------------------------------------------//
  function [lpm_width-1:0] NextBin ;
        input [lpm_width-1:0] count ;
    begin 
	  up_limit = (updown == 1)?(lpm_modulus - 1):0 ;
	  re_start = (updown == 1)?0:(lpm_modulus - 1) ;
	  if(((count >= up_limit) && updown)
		|| ((count == up_limit) && !updown))
		NextBin = re_start ;
	  else
	  	NextBin = (updown == 1)?count+1:count-1 ;
    end 
  endfunction

//---------------------------------------------------------------//
//  function [(1<<lpm_width)-1:0] CountDecode ;
//---------------------------------------------------------------//
  function [lpm_modulus:0] CountDecode ;
    input [lpm_width-1:0] count ;
    integer eq_index ;
    begin
	  CountDecode = 0 ;
	  eq_index = 0;
	  if(count < lpm_modulus)
	  begin
		  eq_index = count ;
	  	  CountDecode[eq_index] = 1'b1 ;
	  end
    end
  endfunction

//---------------------------------------------------------------//
//  function integer str_to_int ;
//---------------------------------------------------------------//
  function integer str_to_int ;
    input  [8*16:1] s; 
    reg [8*16:1] reg_s;
    reg [8:1]   digit ;
    reg [8:1] tmp;
    integer   m , ivalue ; 
    begin 
  
	ivalue = 0;
	reg_s = s;
        for (m=1; m<=16; m= m+1 ) 
        begin 
		tmp = reg_s[128:121];
		digit = tmp & 8'b00001111;
		reg_s = reg_s << 8;	
                ivalue = ivalue * 10 + digit; 
        end
	str_to_int = ivalue;
    end
  endfunction

//---------------------------------------------------------------//

  always @( posedge clock or posedge aclr or posedge aset or 
		posedge aload  )
    begin :asyn_block
      if (aclr)
        begin
          tmp_count = 0 ;
        end
      else if (aset)
        begin
        if (lpm_avalue == "UNUSED")
                tmp_count = {lpm_width{1'b1}};
        else
          	tmp_count = str_to_int(lpm_avalue) ;
        end
      else if (aload)
        begin
          tmp_count = data ;
        end
    else
    begin :syn_block
	  if( clk_en )
	    begin
	      if (sclr)
			begin :syn_clr
				 tmp_count = 0 ;
			end
	      else if (sset)
			begin :syn_set
                                 if (lpm_svalue == "UNUSED")
                                 	tmp_count = {lpm_width{1'b1}};
                                 else
					tmp_count = str_to_int(lpm_svalue) ;
			end
	      else if (sload)
			begin :syn_load
					tmp_count = data ;
			end
	      else if( cnt_en)
		begin
			tmp_count = NextBin(tmp_count) ;
	        end
	    end
    end
    end 

  assign q =  tmp_count ;
  assign eq = CountDecode(tmp_count) ;

 endmodule // lpm_counter

module lpm_decode ( eq, data, enable, clock, aclr) ;

  parameter lpm_type     = "lpm_decode" ;
  parameter lpm_width    = 1 ;
  parameter lpm_decodes  = 1 << lpm_width ;
  parameter lpm_pipeline = 0 ;


  input  [lpm_width-1:0] data ;
  input  enable ;
  input  clock ;
  input  aclr ;
  output [lpm_decodes-1:0] eq ;

  reg    [lpm_decodes-1:0] tmp_eq2 [lpm_pipeline:0] ;
  reg    [lpm_decodes-1:0] tmp_eq;
  integer i, j;


  always @( data or enable)
    begin
	tmp_eq = 0;
	if (enable)
            begin
                if( (data < lpm_decodes))
                    begin
                        tmp_eq[data] = 1'b1 ;
                    end else
			tmp_eq = 0;
	    end
    end
 
    always @(posedge clock or posedge aclr)
    begin
        if (aclr)
            begin 
                for(i = 0; i <= lpm_pipeline; i = i + 1)
            		tmp_eq2[i] = 'b0 ;
            end
   	else 
	begin
        tmp_eq2[lpm_pipeline] = tmp_eq ;
        for(j = 0; j < lpm_pipeline; j = j +1)
            tmp_eq2[j] = tmp_eq2[j+1] ;
	end
      end

  assign eq = (lpm_pipeline > 0) ? tmp_eq2[0] : tmp_eq;

endmodule // lpm_decode

module lpm_ff ( q,
        data, clock, enable,
        aclr, aset,
        sclr, sset,
        aload, sload) ;

  parameter lpm_type = "lpm_ff" ;
  parameter lpm_fftype = "DFF" ;
  parameter lpm_width  = 1 ;
  parameter lpm_avalue = "UNUSED" ;
  parameter lpm_svalue = "UNUSED" ;

  input  [lpm_width-1:0] data ;
  input  clock, enable ;
  input  aclr, aset ;
  input  sclr, sset ;
  input  aload, sload  ;
  output [lpm_width-1:0] q;

  reg   [lpm_width-1:0] tmp_q ;
  integer i ;

//---------------------------------------------------------------//
//  function integer str_to_int ;
//---------------------------------------------------------------//
  function integer str_to_int ;
    input  [8*16:1] s; 
    reg [8*16:1] reg_s;
    reg [8:1]   digit ;
    reg [8:1] tmp;
    integer   m , ivalue ; 
    begin 
  
	ivalue = 0;
	reg_s = s;
        for (m=1; m<=16; m= m+1 ) 
        begin 
		tmp = reg_s[128:121];
		digit = tmp & 8'b00001111;
		reg_s = reg_s << 8;	
                ivalue = ivalue * 10 + digit; 
        end
	str_to_int = ivalue;
    end
  endfunction
//---------------------------------------------------------------//

  always @( posedge clock or posedge aclr or posedge aset or posedge aload )
    begin :asyn_block // Asynchronous process

      if (aclr)
	begin
         	 tmp_q = 0 ;
	end
      else if (aset)
	begin
		if (lpm_avalue == "UNUSED")
			tmp_q = {lpm_width{1'b1}};
		else
			tmp_q = str_to_int(lpm_avalue) ;
	end
      else if (aload)
	begin
         	 tmp_q = data ;
	end
    else

    begin :syn_block // Synchronous process
      	if (enable)
	    begin
		if(sclr)
		  begin
       			tmp_q = 0;
		  end
      		else if (sset )
		  begin
			if (lpm_svalue == "UNUSED") 
       		                tmp_q = {lpm_width{1'b1}}; 
	                else
				tmp_q = str_to_int(lpm_svalue) ;
		  end
      		else if (sload)  // Load data
		  begin
        		tmp_q = data ;
		  end
		else
		  begin
  			if(lpm_fftype == "TFF") // toggle
			  begin
   		             for (i = 0 ; i < lpm_width; i=i+1)
       			         begin
  					if(data[i] == 1'b1) 
  						tmp_q[i] = ~tmp_q[i];
               		 	 end
			  end
  			else 
  			if(lpm_fftype == "DFF") // load data
        			tmp_q = data ;
		  end
	    end
    end
    end