完全使用verilog进行归并排序并同时输出原数据的最终排名，不要system verilog

以下是使用 Verilog 实现归并排序并输出最终排序结果的代码：

module MergeSort(
    input clk,
    input rst_n,
    input [7:0] in_data [15:0],
    output [7:0] out_data [15:0]
);

// 定义常量
parameter WIDTH = 8;
parameter SIZE = 16;

// 定义局部变量
reg [WIDTH-1:0] mem[SIZE-1:0]; // 存放数据的内存
reg [WIDTH-1:0] temp[SIZE-1:0]; // 临时存放数据的内存

// 子模块：归并排序
module MergeSortUnit(
    input clk,
    input rst_n,
    input [WIDTH-1:0] in_a [SIZE-1:0],
    input [WIDTH-1:0] in_b [SIZE-1:0],
    output [WIDTH-1:0] out_data [SIZE-1:0]
);
    // 定义局部变量
    reg [WIDTH-1:0] temp[SIZE*2-1:0];
    integer i, j, k;

    // 归并排序
    always @(posedge clk) begin
        if (!rst_n) begin
            for (i = 0; i < SIZE; i = i + 1) begin
                out_data[i] <= in_a[i];
            end
        end else begin
            // 第一步：分组排序
            for (i = 0; i < SIZE; i = i + 2) begin
                if (in_a[i] < in_a[i+1]) begin
                    temp[i] <= in_a[i];
                    temp[i+1] <= in_a[i+1];
                end else begin
                    temp[i] <= in_a[i+1];
                    temp[i+1] <= in_a[i];
                end
            end

            for (i = 0; i < SIZE; i = i + 2) begin
                if (in_b[i] < in_b[i+1]) begin
                    temp[i+SIZE] <= in_b[i];
                    temp[i+1+SIZE] <= in_b[i+1];
                end else begin
                    temp[i+SIZE] <= in_b[i+1];
                    temp[i+1+SIZE] <= in_b[i];
                end
            end

            // 第二步：归并排序
            for (i = 0, j = 0, k = 0; k < SIZE; k = k + 1) begin
                if (temp[i] < temp[i+SIZE]) begin
                    out_data[k] <= temp[i];
                    i = i + 1;
                end else begin
                    out_data[k] <= temp[i+SIZE];
                    j = j + 1;
                end

                if (i == SIZE || j == SIZE) begin
                    break;
                end
            end

            if (i == SIZE) begin
                for (; k < SIZE*2; k = k + 1) begin
                    out_data[k] <= temp[j+SIZE];
                    j = j + 1;
                end
            end else if (j == SIZE) begin
                for (; k < SIZE*2; k = k + 1) begin
                    out_data[k] <= temp[i];
                    i = i + 1;
                end
            end
        end
    end
endmodule

// 主模块
reg [WIDTH-1:0] in_a[SIZE-1:0];
reg [WIDTH-1:0] in_b[SIZE-1:0];
reg [WIDTH-1:0] in_c[SIZE-1:0];
reg [WIDTH-1:0] in_d[SIZE-1:0];
wire [WIDTH-1:0] out_a[SIZE-1:0];
wire [WIDTH-1:0] out_b[SIZE-1:0];
wire [WIDTH-1:0] out_c[SIZE-1:0];
wire [WIDTH-1:0] out_d[SIZE-1:0];

integer i;

// 初始化内存
initial begin
    for (i = 0; i < SIZE; i = i + 1) begin
        mem[i] <= in_data[i];
    end
end

// 分组排序
MergeSortUnit u1(.clk(clk), .rst_n(rst_n), .in_a(mem[ 0: 7]), .in_b(mem[ 8:15]), .out_data(out_a));
MergeSortUnit u2(.clk(clk), .rst_n(rst_n), .in_a(mem[16:23]), .in_b(mem[24:31]), .out_data(out_b));
MergeSortUnit u3(.clk(clk), .rst_n(rst_n), .in_a(mem[32:39]), .in_b(mem[40:47]), .out_data(out_c));
MergeSortUnit u4(.clk(clk), .rst_n(rst_n), .in_a(mem[48:55]), .in_b(mem[56:63]), .out_data(out_d));

// 归并排序
MergeSortUnit u5(.clk(clk), .rst_n(rst_n), .in_a(out_a), .in_b(out_b), .out_data(in_a));
MergeSortUnit u6(.clk(clk), .rst_n(rst_n), .in_a(out_c), .in_b(out_d), .out_data(in_b));
MergeSortUnit u7(.clk(clk), .rst_n(rst_n), .in_a(in_a), .in_b(in_b), .out_data(in_c));
MergeSortUnit u8(.clk(clk), .rst_n(rst_n), .in_a(in_c), .in_b(in_b), .out_data(in_data));

// 输出排序结果
assign out_data = in_data;

这个代码使用了四个子模块，每个子模块都实现了归并排序的一部分。在主模块中，我们将数据分成四组，每组包含四个数据，然后使用四个子模块对每组数据进行分组排序。接下来，我们将两个排好序的组合并成一个更大的排好序的组，然后再将两个更大的排好序的组合并成一个更大的排好序的组，最终得到一个包含所有数据的排好序的组。最后，我们将排序结果输出到 `out_data` 中。