URL https://opencores.org/ocsvn/rs_encoder_decoder/rs_encoder_decoder/trunk

Subversion Repositories rs_encoder_decoder

[/] [rs_encoder_decoder/] [rtl/] [RS8CalcErrLocPoly8t.v] - Blame information for rev 2

Details | Compare with Previous | View Log


// This is a verilog File Generated
// By The C++ program That Generates
// Gallios Field Error Loc Poly finder using
// Barlekamp Messay Algorithm only contins
// This Contains Only the Circuit
 
module RS8ErrLocPoly8t(clk_i,rst_i,
  valid_i,      // input 1
  delta_i,      // input 1
  step_i,      // input 1
  done_dec_i,      // input 1
  valid_o,    // output 
  sigma_0_o,    // output 
  sigma_last_o,    // output 
  sigma_o,    // output 
  busy_o
  );
  // Declaration of the inputs
  input clk_i,rst_i;
  input valid_i;
  input done_dec_i;
  input [7:0] delta_i;
  input [7:0] step_i;
  output reg valid_o;
  output reg busy_o;
  output wire [71:0] sigma_0_o, sigma_o, sigma_last_o;
 
  // Declaration of Wires are here 
  wire [71:0] arg1;
  wire [71:0] arg2;
  wire [71:0] newSigma;
  wire [7:0] sigma_0_inv;
  wire [7:0] sigma_last_inv;
  wire signed [7:0] inL;
  wire signed [7:0] add_res;
  wire inv_done1, inv_done2;
 
  // Declaration of Register are here 
  reg [71:0] prevSigma, sigma_2L, sigma;
  reg [7:0] prevDelta;
  reg [7:0] L;
  reg [3:0] state;
  reg inv_en;
 
  assign sigma_o = sigma;
  assign sigma_0_o = sigma_2L;
  assign sigma_last_o = prevSigma;
 
  GF8Inverse INVERS1(.clk_i(clk_i),.rst_i(rst_i),
    .valid_i(inv_en),        // 
    .inv_i(sigma[7:0]),     // 
    .valid_o(inv_done1),      // 
    .inv_o(sigma_last_inv));     // 
 
  GF8Inverse INVERS2(.clk_i(clk_i),.rst_i(rst_i),
    .valid_i(inv_en),        // 
    .inv_i(sigma[71:64]),     // 
    .valid_o(inv_done),      // 
    .inv_o(sigma_0_inv));     // 
 
  parameter INIT       = 4'b0000;
  parameter WAIT       = 4'b0001;
  parameter CALCSIGMA1 = 4'b0010;
  parameter CALCSIGMA2 = 4'b0011;
  parameter SHIFT      = 4'b0100;
  parameter UPDATE     = 4'b0101;
  parameter DONESTEP   = 4'b0110;
  parameter INVERSE    = 4'b0111;
  parameter DONEBM     = 4'b1000;
 
  assign add_res = step_i - L;
  assign inL = add_res +1;
 
  // Barlekamp Messey Algorithm State Machine
  always @(posedge clk_i) begin
          if((rst_i)||(done_dec_i))begin
      state <= INIT;
      prevDelta <= 0;
      prevSigma <= 0;
      sigma_2L <= 0;
      sigma <= 0;
      L <= 0;
      valid_o <= 0;
      inv_en <= 0;
      busy_o <= 0;
    end
    else begin
      case(state)
        INIT: begin
          //state transition
          state <= WAIT;
          prevSigma <= 72'b000000010000000000000000000000000000000000000000000000000000000000000000;
          sigma <= 72'b000000010000000000000000000000000000000000000000000000000000000000000000;
          prevDelta <= 8'b00000001;
          sigma_2L <= 72'b000000010000000000000000000000000000000000000000000000000000000000000000;
          L <= 0;
          valid_o <= 0;
          inv_en <= 0;
          busy_o <= 0;
        end
        WAIT: begin
          //state transition
          if((valid_i) && (|delta_i)) begin
            state <= CALCSIGMA1;
          end
                else if((valid_i) && (~(|delta_i)))begin
            state <= SHIFT;
          end
          else begin
            state <= WAIT;
          end
          prevSigma <= prevSigma;
          prevDelta <= prevDelta;
          sigma_2L  <= sigma_2L;
          sigma <= sigma;
          L <= L;
          valid_o <= 0;
          inv_en <= 0;
          busy_o <= 0;
        end
        CALCSIGMA1: begin
          //state transition
          state <= CALCSIGMA2;
          //output transition
          prevSigma <= sigma;
          sigma <= sigma;
          prevDelta <= prevDelta;
          sigma_2L <= sigma_2L;
          L <= L;
          valid_o <= 0;
          inv_en <= 0;
          busy_o <= 0;
        end
        CALCSIGMA2: begin
          //state transition
                if (step_i<(L<<1))
            state <= SHIFT;
          else
            state <= UPDATE;
          //output transition
          prevSigma <= prevSigma;
          sigma <= newSigma;
          prevDelta <= prevDelta;
          sigma_2L <= sigma_2L;
          L <= L;
          valid_o <= 0;
          inv_en <= 0;
          busy_o <= 0;
        end
        SHIFT: begin
          state <= DONESTEP;
          //output transition
          prevSigma <= prevSigma;
          sigma <= sigma;
          prevDelta <= prevDelta;
          sigma_2L <= {1'b0,1'b0,1'b0,1'b0,1'b0,1'b0,1'b0,1'b0,1'b0, sigma_2L[71:8]};
          L <= L;
          valid_o <= 0;
          inv_en <= 0;
          busy_o <= 0;
        end
        UPDATE: begin
          state <= DONESTEP;
          valid_o <= 0;
          prevSigma <= prevSigma;
          sigma <= sigma;
          prevDelta <= delta_i;
          sigma_2L <= {1'b0,1'b0,1'b0,1'b0,1'b0,1'b0,1'b0,1'b0,1'b0, prevSigma[71:8]};
          L <= inL;
          valid_o <= 0;
          inv_en <= 0;
          busy_o <= 0;
        end
        DONESTEP: begin
          if (step_i < 15) begin
            state <= WAIT;
            inv_en <= 0;
          end
          else begin
            state <= INVERSE;
            inv_en <= 1;
          end
          prevSigma <= prevSigma;
          prevDelta <= prevDelta;
          sigma_2L <= sigma_2L;
          sigma <= sigma;
          L <= L;
          valid_o <= 1;
          busy_o <= 0;
        end
        INVERSE: begin
          if (inv_done) begin
            state <= DONEBM;
          end
          else begin
            state <= INVERSE;
          end
          prevDelta <= prevDelta;
          sigma <= sigma;
          sigma_2L <= {sigma[63:0],sigma_0_inv};
          prevSigma <={sigma[71:8],sigma_last_inv};
          L <= L;
          valid_o <= 0;
          inv_en <= 0;
          busy_o <= 1;
        end
        DONEBM: begin
          if(done_dec_i)
            state <= INIT;
          else
            state <= DONEBM;
          prevSigma <= prevSigma;
          prevDelta <= prevDelta;
          sigma_2L <= sigma_2L;
          sigma <= sigma;
          L <= L;
          valid_o <= 0;
          inv_en <= 0;
          busy_o <= 0;
        end
        default: begin
          state <= INIT;
          prevSigma <= prevSigma;
          prevDelta <= prevDelta;
          sigma_2L <= sigma_2L;
          sigma <= sigma;
          L <= 0;
          inv_en <= 0;
          busy_o <= 0;
          valid_o <= 0;
        end
      endcase
    end
  end
 
 ////////// ARG1 Multiplication ////////// 
    GF8GenMult ARG1MULT0(
      .mult_i1(prevSigma[7:0]), // Generic Multiplier input 1
      .mult_i2(prevDelta), // Generic Multiplier input 2
      .mult_o(arg1[7:0])); // Generic Multiplier output
    GF8GenMult ARG1MULT1(
      .mult_i1(prevSigma[15:8]), // Generic Multiplier input 1
      .mult_i2(prevDelta), // Generic Multiplier input 2
      .mult_o(arg1[15:8])); // Generic Multiplier output
    GF8GenMult ARG1MULT2(
      .mult_i1(prevSigma[23:16]), // Generic Multiplier input 1
      .mult_i2(prevDelta), // Generic Multiplier input 2
      .mult_o(arg1[23:16])); // Generic Multiplier output
    GF8GenMult ARG1MULT3(
      .mult_i1(prevSigma[31:24]), // Generic Multiplier input 1
      .mult_i2(prevDelta), // Generic Multiplier input 2
      .mult_o(arg1[31:24])); // Generic Multiplier output
    GF8GenMult ARG1MULT4(
      .mult_i1(prevSigma[39:32]), // Generic Multiplier input 1
      .mult_i2(prevDelta), // Generic Multiplier input 2
      .mult_o(arg1[39:32])); // Generic Multiplier output
    GF8GenMult ARG1MULT5(
      .mult_i1(prevSigma[47:40]), // Generic Multiplier input 1
      .mult_i2(prevDelta), // Generic Multiplier input 2
      .mult_o(arg1[47:40])); // Generic Multiplier output
    GF8GenMult ARG1MULT6(
      .mult_i1(prevSigma[55:48]), // Generic Multiplier input 1
      .mult_i2(prevDelta), // Generic Multiplier input 2
      .mult_o(arg1[55:48])); // Generic Multiplier output
    GF8GenMult ARG1MULT7(
      .mult_i1(prevSigma[63:56]), // Generic Multiplier input 1
      .mult_i2(prevDelta), // Generic Multiplier input 2
      .mult_o(arg1[63:56])); // Generic Multiplier output
    GF8GenMult ARG1MULT8(
      .mult_i1(prevSigma[71:64]), // Generic Multiplier input 1
      .mult_i2(prevDelta), // Generic Multiplier input 2
      .mult_o(arg1[71:64])); // Generic Multiplier output
 
 
 ////////// ARG2 Multiplication ////////// 
    GF8GenMult ARG2MULT0(
      .mult_i1(sigma_2L[7:0]), // Generic Multiplier input 1
      .mult_i2(delta_i), // Generic Multiplier input 2
      .mult_o(arg2[7:0])); // Generic Multiplier output
    GF8GenMult ARG2MULT1(
      .mult_i1(sigma_2L[15:8]), // Generic Multiplier input 1
      .mult_i2(delta_i), // Generic Multiplier input 2
      .mult_o(arg2[15:8])); // Generic Multiplier output
    GF8GenMult ARG2MULT2(
      .mult_i1(sigma_2L[23:16]), // Generic Multiplier input 1
      .mult_i2(delta_i), // Generic Multiplier input 2
      .mult_o(arg2[23:16])); // Generic Multiplier output
    GF8GenMult ARG2MULT3(
      .mult_i1(sigma_2L[31:24]), // Generic Multiplier input 1
      .mult_i2(delta_i), // Generic Multiplier input 2
      .mult_o(arg2[31:24])); // Generic Multiplier output
    GF8GenMult ARG2MULT4(
      .mult_i1(sigma_2L[39:32]), // Generic Multiplier input 1
      .mult_i2(delta_i), // Generic Multiplier input 2
      .mult_o(arg2[39:32])); // Generic Multiplier output
    GF8GenMult ARG2MULT5(
      .mult_i1(sigma_2L[47:40]), // Generic Multiplier input 1
      .mult_i2(delta_i), // Generic Multiplier input 2
      .mult_o(arg2[47:40])); // Generic Multiplier output
    GF8GenMult ARG2MULT6(
      .mult_i1(sigma_2L[55:48]), // Generic Multiplier input 1
      .mult_i2(delta_i), // Generic Multiplier input 2
      .mult_o(arg2[55:48])); // Generic Multiplier output
    GF8GenMult ARG2MULT7(
      .mult_i1(sigma_2L[63:56]), // Generic Multiplier input 1
      .mult_i2(delta_i), // Generic Multiplier input 2
      .mult_o(arg2[63:56])); // Generic Multiplier output
    GF8GenMult ARG2MULT8(
      .mult_i1(sigma_2L[71:64]), // Generic Multiplier input 1
      .mult_i2(delta_i), // Generic Multiplier input 2
      .mult_o(arg2[71:64])); // Generic Multiplier output
 
 
 ////////// SIGMA ADDER////////// 
    GF8SigmaAdder8t ARG1CT(
      .arg_i1(arg1),
      .arg_i2(arg2),
      .NewSigma(newSigma)
    );
 
endmodule

Browse

Tools

Subversion Repositories rs_encoder_decoder

[/] [rs_encoder_decoder/] [rtl/] [RS8CalcErrLocPoly8t.v] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	farooq21	`// This is a verilog File Generated`
2			`// By The C++ program That Generates`
3			`// Gallios Field Error Loc Poly finder using`
4			`// Barlekamp Messay Algorithm only contins`
5			`// This Contains Only the Circuit`
6
7			`module RS8ErrLocPoly8t(clk_i,rst_i,`
8			`valid_i, // input 1`
9			`delta_i, // input 1`
10			`step_i, // input 1`
11			`done_dec_i, // input 1`
12			`valid_o, // output`
13			`sigma_0_o, // output`
14			`sigma_last_o, // output`
15			`sigma_o, // output`
16			`busy_o`
17			`);`
18			`// Declaration of the inputs`
19			`input clk_i,rst_i;`
20			`input valid_i;`
21			`input done_dec_i;`
22			`input [7:0] delta_i;`
23			`input [7:0] step_i;`
24			`output reg valid_o;`
25			`output reg busy_o;`
26			`output wire [71:0] sigma_0_o, sigma_o, sigma_last_o;`
27
28			`// Declaration of Wires are here`
29			`wire [71:0] arg1;`
30			`wire [71:0] arg2;`
31			`wire [71:0] newSigma;`
32			`wire [7:0] sigma_0_inv;`
33			`wire [7:0] sigma_last_inv;`
34			`wire signed [7:0] inL;`
35			`wire signed [7:0] add_res;`
36			`wire inv_done1, inv_done2;`
37
38			`// Declaration of Register are here`
39			`reg [71:0] prevSigma, sigma_2L, sigma;`
40			`reg [7:0] prevDelta;`
41			`reg [7:0] L;`
42			`reg [3:0] state;`
43			`reg inv_en;`
44
45			`assign sigma_o = sigma;`
46			`assign sigma_0_o = sigma_2L;`
47			`assign sigma_last_o = prevSigma;`
48
49			`GF8Inverse INVERS1(.clk_i(clk_i),.rst_i(rst_i),`
50			`.valid_i(inv_en), //`
51			`.inv_i(sigma[7:0]), //`
52			`.valid_o(inv_done1), //`
53			`.inv_o(sigma_last_inv)); //`
54
55			`GF8Inverse INVERS2(.clk_i(clk_i),.rst_i(rst_i),`
56			`.valid_i(inv_en), //`
57			`.inv_i(sigma[71:64]), //`
58			`.valid_o(inv_done), //`
59			`.inv_o(sigma_0_inv)); //`
60
61			`parameter INIT = 4'b0000;`
62			`parameter WAIT = 4'b0001;`
63			`parameter CALCSIGMA1 = 4'b0010;`
64			`parameter CALCSIGMA2 = 4'b0011;`
65			`parameter SHIFT = 4'b0100;`
66			`parameter UPDATE = 4'b0101;`
67			`parameter DONESTEP = 4'b0110;`
68			`parameter INVERSE = 4'b0111;`
69			`parameter DONEBM = 4'b1000;`
70
71			`assign add_res = step_i - L;`
72			`assign inL = add_res +1;`
73
74			`// Barlekamp Messey Algorithm State Machine`
75			`always @(posedge clk_i) begin`
76			`if((rst_i)\|\|(done_dec_i))begin`
77			`state <= INIT;`
78			`prevDelta <= 0;`
79			`prevSigma <= 0;`
80			`sigma_2L <= 0;`
81			`sigma <= 0;`
82			`L <= 0;`
83			`valid_o <= 0;`
84			`inv_en <= 0;`
85			`busy_o <= 0;`
86			`end`
87			`else begin`
88			`case(state)`
89			`INIT: begin`
90			`//state transition`
91			`state <= WAIT;`
92			`prevSigma <= 72'b000000010000000000000000000000000000000000000000000000000000000000000000;`
93			`sigma <= 72'b000000010000000000000000000000000000000000000000000000000000000000000000;`
94			`prevDelta <= 8'b00000001;`
95			`sigma_2L <= 72'b000000010000000000000000000000000000000000000000000000000000000000000000;`
96			`L <= 0;`
97			`valid_o <= 0;`
98			`inv_en <= 0;`
99			`busy_o <= 0;`
100			`end`
101			`WAIT: begin`
102			`//state transition`
103			`if((valid_i) && (\|delta_i)) begin`
104			`state <= CALCSIGMA1;`
105			`end`
106			`else if((valid_i) && (~(\|delta_i)))begin`
107			`state <= SHIFT;`
108			`end`
109			`else begin`
110			`state <= WAIT;`
111			`end`
112			`prevSigma <= prevSigma;`
113			`prevDelta <= prevDelta;`
114			`sigma_2L <= sigma_2L;`
115			`sigma <= sigma;`
116			`L <= L;`
117			`valid_o <= 0;`
118			`inv_en <= 0;`
119			`busy_o <= 0;`
120			`end`
121			`CALCSIGMA1: begin`
122			`//state transition`
123			`state <= CALCSIGMA2;`
124			`//output transition`
125			`prevSigma <= sigma;`
126			`sigma <= sigma;`
127			`prevDelta <= prevDelta;`
128			`sigma_2L <= sigma_2L;`
129			`L <= L;`
130			`valid_o <= 0;`
131			`inv_en <= 0;`
132			`busy_o <= 0;`
133			`end`
134			`CALCSIGMA2: begin`
135			`//state transition`
136			`if (step_i<(L<<1))`
137			`state <= SHIFT;`
138			`else`
139			`state <= UPDATE;`
140			`//output transition`
141			`prevSigma <= prevSigma;`
142			`sigma <= newSigma;`
143			`prevDelta <= prevDelta;`
144			`sigma_2L <= sigma_2L;`
145			`L <= L;`
146			`valid_o <= 0;`
147			`inv_en <= 0;`
148			`busy_o <= 0;`
149			`end`
150			`SHIFT: begin`
151			`state <= DONESTEP;`
152			`//output transition`
153			`prevSigma <= prevSigma;`
154			`sigma <= sigma;`
155			`prevDelta <= prevDelta;`
156			`sigma_2L <= {1'b0,1'b0,1'b0,1'b0,1'b0,1'b0,1'b0,1'b0,1'b0, sigma_2L[71:8]};`
157			`L <= L;`
158			`valid_o <= 0;`
159			`inv_en <= 0;`
160			`busy_o <= 0;`
161			`end`
162			`UPDATE: begin`
163			`state <= DONESTEP;`
164			`valid_o <= 0;`
165			`prevSigma <= prevSigma;`
166			`sigma <= sigma;`
167			`prevDelta <= delta_i;`
168			`sigma_2L <= {1'b0,1'b0,1'b0,1'b0,1'b0,1'b0,1'b0,1'b0,1'b0, prevSigma[71:8]};`
169			`L <= inL;`
170			`valid_o <= 0;`
171			`inv_en <= 0;`
172			`busy_o <= 0;`
173			`end`
174			`DONESTEP: begin`
175			`if (step_i < 15) begin`
176			`state <= WAIT;`
177			`inv_en <= 0;`
178			`end`
179			`else begin`
180			`state <= INVERSE;`
181			`inv_en <= 1;`
182			`end`
183			`prevSigma <= prevSigma;`
184			`prevDelta <= prevDelta;`
185			`sigma_2L <= sigma_2L;`
186			`sigma <= sigma;`
187			`L <= L;`
188			`valid_o <= 1;`
189			`busy_o <= 0;`
190			`end`
191			`INVERSE: begin`
192			`if (inv_done) begin`
193			`state <= DONEBM;`
194			`end`
195			`else begin`
196			`state <= INVERSE;`
197			`end`
198			`prevDelta <= prevDelta;`
199			`sigma <= sigma;`
200			`sigma_2L <= {sigma[63:0],sigma_0_inv};`
201			`prevSigma <={sigma[71:8],sigma_last_inv};`
202			`L <= L;`
203			`valid_o <= 0;`
204			`inv_en <= 0;`
205			`busy_o <= 1;`
206			`end`
207			`DONEBM: begin`
208			`if(done_dec_i)`
209			`state <= INIT;`
210			`else`
211			`state <= DONEBM;`
212			`prevSigma <= prevSigma;`
213			`prevDelta <= prevDelta;`
214			`sigma_2L <= sigma_2L;`
215			`sigma <= sigma;`
216			`L <= L;`
217			`valid_o <= 0;`
218			`inv_en <= 0;`
219			`busy_o <= 0;`
220			`end`
221			`default: begin`
222			`state <= INIT;`
223			`prevSigma <= prevSigma;`
224			`prevDelta <= prevDelta;`
225			`sigma_2L <= sigma_2L;`
226			`sigma <= sigma;`
227			`L <= 0;`
228			`inv_en <= 0;`
229			`busy_o <= 0;`
230			`valid_o <= 0;`
231			`end`
232			`endcase`
233			`end`
234			`end`
235
236			`////////// ARG1 Multiplication //////////`
237			`GF8GenMult ARG1MULT0(`
238			`.mult_i1(prevSigma[7:0]), // Generic Multiplier input 1`
239			`.mult_i2(prevDelta), // Generic Multiplier input 2`
240			`.mult_o(arg1[7:0])); // Generic Multiplier output`
241			`GF8GenMult ARG1MULT1(`
242			`.mult_i1(prevSigma[15:8]), // Generic Multiplier input 1`
243			`.mult_i2(prevDelta), // Generic Multiplier input 2`
244			`.mult_o(arg1[15:8])); // Generic Multiplier output`
245			`GF8GenMult ARG1MULT2(`
246			`.mult_i1(prevSigma[23:16]), // Generic Multiplier input 1`
247			`.mult_i2(prevDelta), // Generic Multiplier input 2`
248			`.mult_o(arg1[23:16])); // Generic Multiplier output`
249			`GF8GenMult ARG1MULT3(`
250			`.mult_i1(prevSigma[31:24]), // Generic Multiplier input 1`
251			`.mult_i2(prevDelta), // Generic Multiplier input 2`
252			`.mult_o(arg1[31:24])); // Generic Multiplier output`
253			`GF8GenMult ARG1MULT4(`
254			`.mult_i1(prevSigma[39:32]), // Generic Multiplier input 1`
255			`.mult_i2(prevDelta), // Generic Multiplier input 2`
256			`.mult_o(arg1[39:32])); // Generic Multiplier output`
257			`GF8GenMult ARG1MULT5(`
258			`.mult_i1(prevSigma[47:40]), // Generic Multiplier input 1`
259			`.mult_i2(prevDelta), // Generic Multiplier input 2`
260			`.mult_o(arg1[47:40])); // Generic Multiplier output`
261			`GF8GenMult ARG1MULT6(`
262			`.mult_i1(prevSigma[55:48]), // Generic Multiplier input 1`
263			`.mult_i2(prevDelta), // Generic Multiplier input 2`
264			`.mult_o(arg1[55:48])); // Generic Multiplier output`
265			`GF8GenMult ARG1MULT7(`
266			`.mult_i1(prevSigma[63:56]), // Generic Multiplier input 1`
267			`.mult_i2(prevDelta), // Generic Multiplier input 2`
268			`.mult_o(arg1[63:56])); // Generic Multiplier output`
269			`GF8GenMult ARG1MULT8(`
270			`.mult_i1(prevSigma[71:64]), // Generic Multiplier input 1`
271			`.mult_i2(prevDelta), // Generic Multiplier input 2`
272			`.mult_o(arg1[71:64])); // Generic Multiplier output`
273
274
275			`////////// ARG2 Multiplication //////////`
276			`GF8GenMult ARG2MULT0(`
277			`.mult_i1(sigma_2L[7:0]), // Generic Multiplier input 1`
278			`.mult_i2(delta_i), // Generic Multiplier input 2`
279			`.mult_o(arg2[7:0])); // Generic Multiplier output`
280			`GF8GenMult ARG2MULT1(`
281			`.mult_i1(sigma_2L[15:8]), // Generic Multiplier input 1`
282			`.mult_i2(delta_i), // Generic Multiplier input 2`
283			`.mult_o(arg2[15:8])); // Generic Multiplier output`
284			`GF8GenMult ARG2MULT2(`
285			`.mult_i1(sigma_2L[23:16]), // Generic Multiplier input 1`
286			`.mult_i2(delta_i), // Generic Multiplier input 2`
287			`.mult_o(arg2[23:16])); // Generic Multiplier output`
288			`GF8GenMult ARG2MULT3(`
289			`.mult_i1(sigma_2L[31:24]), // Generic Multiplier input 1`
290			`.mult_i2(delta_i), // Generic Multiplier input 2`
291			`.mult_o(arg2[31:24])); // Generic Multiplier output`
292			`GF8GenMult ARG2MULT4(`
293			`.mult_i1(sigma_2L[39:32]), // Generic Multiplier input 1`
294			`.mult_i2(delta_i), // Generic Multiplier input 2`
295			`.mult_o(arg2[39:32])); // Generic Multiplier output`
296			`GF8GenMult ARG2MULT5(`
297			`.mult_i1(sigma_2L[47:40]), // Generic Multiplier input 1`
298			`.mult_i2(delta_i), // Generic Multiplier input 2`
299			`.mult_o(arg2[47:40])); // Generic Multiplier output`
300			`GF8GenMult ARG2MULT6(`
301			`.mult_i1(sigma_2L[55:48]), // Generic Multiplier input 1`
302			`.mult_i2(delta_i), // Generic Multiplier input 2`
303			`.mult_o(arg2[55:48])); // Generic Multiplier output`
304			`GF8GenMult ARG2MULT7(`
305			`.mult_i1(sigma_2L[63:56]), // Generic Multiplier input 1`
306			`.mult_i2(delta_i), // Generic Multiplier input 2`
307			`.mult_o(arg2[63:56])); // Generic Multiplier output`
308			`GF8GenMult ARG2MULT8(`
309			`.mult_i1(sigma_2L[71:64]), // Generic Multiplier input 1`
310			`.mult_i2(delta_i), // Generic Multiplier input 2`
311			`.mult_o(arg2[71:64])); // Generic Multiplier output`
312
313
314			`////////// SIGMA ADDER//////////`
315			`GF8SigmaAdder8t ARG1CT(`
316			`.arg_i1(arg1),`
317			`.arg_i2(arg2),`
318			`.NewSigma(newSigma)`
319			`);`
320
321			`endmodule`