I want to change all the variable names that can be changed. Please give me instructions that show the before and after so that it's easy for me to make the changes.

localparam S_IDLE    = 2'b00;
localparam S_PROCESS = 2'b01;
localparam W_ADDR    = 2'b01;
localparam W_DATA    = 2'b10;
localparam W_RESP    = 2'b11;

reg AR_state, AR_state_n, R_state, R_state_n;
reg [1:0]    WRITE_state, WRITE_state_n;
reg [6:0]    R_count, R_count_n;
reg [3:0]    W_count, W_count_n;
reg [2:0]    AR_count, AR_count_n, mat_width_reg;

reg arvalid, rready, awvalid, wvalid, wlast;
reg [31:0]    araddr, wdata;
reg [127:0] rdata;

always_ff @(posedge clk) begin
    if (!rst_n) begin
        AR_state <= S_IDLE;
        R_state <= S_IDLE;
        WRITE_state <= S_IDLE;

        R_count <= 7'd0;
        W_count <= 4'd0;
        AR_count <= 3'd0;

        mat_width_reg <= 3'd0;
    end
    else begin
        AR_state <= AR_state_n;
        R_state <= R_state_n;
        WRITE_state <= WRITE_state_n;

        R_count <= R_count_n;
        W_count <= W_count_n;
        AR_count <= AR_count_n;
        mat_width_reg <= mat_width_i[4:2];
    end
end

always_comb begin
    AR_state_n = AR_state;
    R_state_n = R_state;
    WRITE_state_n = WRITE_state;

    R_count_n = R_count;
    W_count_n = W_count;
    AR_count_n = AR_count;

    buf_a_wren_o = 1'b0;
    buf_b_wren_o = 1'b0;

    araddr = 32'b0;
    
    arvalid = 1'b0;
    rready = 1'b0;
    awvalid = 1'b0;
    wvalid = 1'b0;
    wlast = 1'b0;

    mm_start_o = 1'b0;

    case(AR_state)
        S_IDLE:begin
            if (start_i) begin
                AR_state_n = S_PROCESS;
                arvalid = 1'b1;
                araddr = mat_a_addr_i;
            end
        end
        S_PROCESS:begin
            arvalid = 1'b1;
            araddr = (AR_count < mat_width_reg) ? mat_a_addr_i + {AR_count,6'b0} : mat_b_addr_i + {(AR_count-mat_width_reg), 6'b0};

            if (axi_ar_if.arready) begin
                if (AR_count != {mat_width_reg,1'b0} - 1'd1) begin
                    AR_count_n = AR_count + 3'd1;
                end
                else begin
                    AR_state_n = S_IDLE;
                    AR_count_n = 3'd0;
                end
            end
        end
    endcase

    case(R_state)
        S_IDLE:begin
            if (axi_ar_if.arready) begin
                R_state_n = S_PROCESS;
            end
        end
        S_PROCESS:begin
            rready = 1'b1;

            if (axi_r_if.rvalid) begin

                if (R_count[6:4] < mat_width_reg) begin
                    buf_a_wren_o = 1'b1;
                end
                else begin
                    buf_b_wren_o = 1'b1;
                end

                if ((R_count[6:4] == mat_width_i[4:1] - 1'd1) & axi_r_if.rlast) begin
                    R_count_n = 7'd0;
                    R_state_n = S_IDLE;
                    mm_start_o = 1'b1;
                end
                else begin
                    R_count_n = R_count + 7'd1;
                end
            end
        end
    endcase
    
    case(WRITE_state)
        S_IDLE:begin
            if (mm_start_o) begin
                WRITE_state_n = W_ADDR;
            end
        end
        W_ADDR:begin
            awvalid = mm_done_i;

            if (axi_aw_if.awready) begin
                WRITE_state_n = W_DATA;
            end
        end
        W_DATA:begin
            wvalid = 1'b1;
        
            if (W_count == 4'hF) begin
                wlast = 1'b1;
            end
            
            if (axi_w_if.wready) begin
                if (W_count != 4'hF) begin
                    W_count_n = W_count + 4'd1;
                end
                else begin
                    W_count_n = 4'd0;
                    WRITE_state_n = W_RESP;
                end
            end
        end
        W_RESP:begin
            if (axi_b_if.bvalid) begin
                WRITE_state_n = S_IDLE;
            end
        end
    endcase
end

function automatic [15:0] get_strobe(input [1:0] R_count);
    case(R_count)
        2'b00: get_strobe = 16'h000F;
        2'b01: get_strobe = 16'h00F0;
        2'b10: get_strobe = 16'h0F00;
        2'b11: get_strobe = 16'hF000;
    endcase
endfunction

function automatic [127:0] get_rdata(input [1:0] R_count, input [31:0] axi_rdata);
    case(R_count)
        2'b00: get_rdata = {96'b0, axi_rdata};
        2'b01: get_rdata = {64'b0, axi_rdata, 32'b0};
        2'b10: get_rdata = {32'b0, axi_rdata, 64'b0};
        2'b11: get_rdata = {axi_rdata, 96'b0};
    endcase
endfunction

always_comb begin
    rdata = get_rdata(R_count[1:0], axi_r_if.rdata);
    wdata = accum_i[3 - (W_count >> 2)][3 - (W_count & 4'd3)][31:0];
end

assign done_o = !(AR_state || R_state || WRITE_state[1] || WRITE_state[0]);
assign buf_a_wbyteenable_o = get_strobe(R_count[1:0]);
assign buf_b_wbyteenable_o = get_strobe(R_count[1:0]);
assign buf_a_waddr_o = R_count[6:2];
assign buf_b_waddr_o = R_count[6:2] - mat_width_i;
assign buf_a_wdata_o = rdata;
assign buf_b_wdata_o = rdata;
assign axi_ar_if.arvalid = arvalid;
assign axi_ar_if.arsize = 3'b010;
assign axi_ar_if.arburst = 2'b01;
assign axi_ar_if.araddr = araddr;
assign axi_ar_if.arlen = 4'hF;
assign axi_r_if.rready = rready;
assign axi_aw_if.awlen = 4'hF;
assign axi_aw_if.awsize = 3'b010;
assign axi_aw_if.awburst = 2'b01;
assign axi_aw_if.awvalid = awvalid;
assign axi_aw_if.awaddr = mat_c_addr_i;
assign axi_b_if.bready = 1'b1;
assign axi_w_if.wdata = wdata;
assign axi_w_if.wstrb = 4'b1111;
assign axi_w_if.wvalid = wvalid;
assign axi_w_if.wlast = wlast;