OpenCores
URL https://opencores.org/ocsvn/hdl-deflate/hdl-deflate/trunk

Subversion Repositories hdl-deflate

[/] [hdl-deflate/] [trunk/] [test_fast_bench.v] - Blame information for rev 7

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 tomtor
// File: test_fast_bench.v
2
// Generated by MyHDL 0.10
3
// Date: Thu Dec 20 18:23:04 2018
4
 
5
 
6
`timescale 1ns/10ps
7
 
8
module test_fast_bench (
9
    i_clk,
10
    o_led,
11
    led0_g,
12
    led1_b,
13
    led2_r
14
);
15
 
16
 
17
output i_clk;
18
reg i_clk;
19
output [3:0] o_led;
20
reg [3:0] o_led;
21
output led0_g;
22
reg led0_g;
23
output led1_b;
24
reg led1_b;
25
output led2_r;
26
reg led2_r;
27
 
28
reg [12:0] o_iprogress = 0;
29
reg [12:0] resultlen = 0;
30
reg reset = 1;
31
reg [12:0] o_oprogress = 0;
32
reg o_done = 0;
33
reg [7:0] o_byte = 0;
34
reg [2:0] i_mode = 0;
35
reg [7:0] i_data = 0;
36
reg [12:0] i_addr = 0;
37
reg wtick = 0;
38
reg [4:0] tstate = 5'b00000;
39
reg [14:0] tbi = 0;
40
reg [0:0] scounter = 0;
41
reg [5:0] resume = 0;
42
reg [15:0] counter = 0;
43
reg [7:0] copy = 0;
44
reg [18:0] deflate0_0_wleaf = 0;
45
reg [9:0] deflate0_0_step = 0;
46
reg deflate0_0_static = 0;
47
reg [4:0] deflate0_0_state = 5'b00000;
48
reg [8:0] deflate0_0_spread_i = 0;
49
reg [9:0] deflate0_0_spread = 0;
50
reg [9:0] deflate0_0_reverse = 0;
51
reg [7:0] deflate0_0_orbyte = 0;
52
reg [12:0] deflate0_0_oraddr = 0;
53
reg [12:0] deflate0_0_offset = 0;
54
reg [7:0] deflate0_0_obyte = 0;
55
reg [7:0] deflate0_0_ob1 = 0;
56
reg [12:0] deflate0_0_oaddr = 0;
57
reg [8:0] deflate0_0_numLiterals = 0;
58
reg [5:0] deflate0_0_numDistance = 0;
59
reg [8:0] deflate0_0_numCodeLength = 0;
60
reg [2:0] deflate0_0_nb = 0;
61
reg [4:0] deflate0_0_minBits = 0;
62
reg [2:0] deflate0_0_method = 0;
63
reg [4:0] deflate0_0_maxBits = 0;
64
reg [8:0] deflate0_0_lwaddr = 0;
65
reg [12:0] deflate0_0_length = 0;
66
reg [18:0] deflate0_0_leaf = 0;
67
reg [14:0] deflate0_0_lastToken = 0;
68
reg [15:0] deflate0_0_ladler1 = 0;
69
reg [12:0] deflate0_0_isize = 0;
70
reg [9:0] deflate0_0_instantMaxBit = 0;
71
reg [14:0] deflate0_0_instantMask = 0;
72
reg [8:0] deflate0_0_howOften = 0;
73
reg deflate0_0_flush = 0;
74
reg deflate0_0_final = 0;
75
reg deflate0_0_filled = 0;
76
reg [2:0] deflate0_0_doo = 0;
77
reg deflate0_0_do_compress = 0;
78
reg [12:0] deflate0_0_do = 0;
79
reg [2:0] deflate0_0_dio = 0;
80
reg [12:0] deflate0_0_di = 0;
81
reg [4:0] deflate0_0_d_maxBits = 0;
82
reg [9:0] deflate0_0_d_instantMaxBit = 0;
83
reg [14:0] deflate0_0_d_instantMask = 0;
84
reg [8:0] deflate0_0_cur_static = 0;
85
reg signed [7:0] deflate0_0_cur_search = 0;
86
reg deflate0_0_cur_next = 0;
87
reg [12:0] deflate0_0_cur_i = 0;
88
reg signed [7:0] deflate0_0_cur_dist = 0;
89
reg [12:0] deflate0_0_cur_cstatic = 0;
90
reg [9:0] deflate0_0_cur_HF1 = 0;
91
reg [7:0] deflate0_0_copy1 = 0;
92
reg [14:0] deflate0_0_code = 0;
93
reg [3:0] deflate0_0_bits = 0;
94
reg [8:0] deflate0_0_b_numCodeLength = 0;
95
wire [31:0] deflate0_0_b41;
96
reg [7:0] deflate0_0_b4 = 0;
97
reg [7:0] deflate0_0_b3 = 0;
98
reg [7:0] deflate0_0_b2 = 0;
99
reg [7:0] deflate0_0_b1 = 0;
100
reg [15:0] deflate0_0_adler2 = 0;
101
reg [15:0] deflate0_0_adler1 = 0;
102
reg [7:0] deflate0_0_oram [0:8192-1];
103
 
104
initial begin: INITIALIZE_DEFLATE0_0_ORAM
105
    integer i;
106
    for(i=0; i<8192; i=i+1) begin
107
        deflate0_0_oram[i] = 0;
108
    end
109
end
110
 
111
reg [9:0] deflate0_0_nextCode [0:15-1];
112
 
113
initial begin: INITIALIZE_DEFLATE0_0_NEXTCODE
114
    integer i;
115
    for(i=0; i<15; i=i+1) begin
116
        deflate0_0_nextCode[i] = 0;
117
    end
118
end
119
 
120
reg [18:0] deflate0_0_leaves [0:512-1];
121
 
122
initial begin: INITIALIZE_DEFLATE0_0_LEAVES
123
    integer i;
124
    for(i=0; i<512; i=i+1) begin
125
        deflate0_0_leaves[i] = 0;
126
    end
127
end
128
 
129
reg [7:0] deflate0_0_iram [0:128-1];
130
 
131
initial begin: INITIALIZE_DEFLATE0_0_IRAM
132
    integer i;
133
    for(i=0; i<128; i=i+1) begin
134
        deflate0_0_iram[i] = 0;
135
    end
136
end
137
 
138
reg [3:0] deflate0_0_distanceLength [0:32-1];
139
 
140
initial begin: INITIALIZE_DEFLATE0_0_DISTANCELENGTH
141
    integer i;
142
    for(i=0; i<32; i=i+1) begin
143
        deflate0_0_distanceLength[i] = 0;
144
    end
145
end
146
 
147
reg [18:0] deflate0_0_d_leaves [0:128-1];
148
 
149
initial begin: INITIALIZE_DEFLATE0_0_D_LEAVES
150
    integer i;
151
    for(i=0; i<128; i=i+1) begin
152
        deflate0_0_d_leaves[i] = 0;
153
    end
154
end
155
 
156
reg [8:0] deflate0_0_code_bits [0:288-1];
157
 
158
initial begin: INITIALIZE_DEFLATE0_0_CODE_BITS
159
    integer i;
160
    for(i=0; i<288; i=i+1) begin
161
        deflate0_0_code_bits[i] = 0;
162
    end
163
end
164
 
165
reg [3:0] deflate0_0_codeLength [0:290-1];
166
 
167
initial begin: INITIALIZE_DEFLATE0_0_CODELENGTH
168
    integer i;
169
    for(i=0; i<290; i=i+1) begin
170
        deflate0_0_codeLength[i] = 0;
171
    end
172
end
173
 
174
reg [8:0] deflate0_0_bitLengthCount [0:16-1];
175
 
176
initial begin: INITIALIZE_DEFLATE0_0_BITLENGTHCOUNT
177
    integer i;
178
    for(i=0; i<16; i=i+1) begin
179
        deflate0_0_bitLengthCount[i] = 0;
180
    end
181
end
182
 
183
 
184
assign deflate0_0_b41[32-1:24] = deflate0_0_b4;
185
assign deflate0_0_b41[24-1:16] = deflate0_0_b3;
186
assign deflate0_0_b41[16-1:8] = deflate0_0_b2;
187
assign deflate0_0_b41[8-1:0] = deflate0_0_b1;
188
 
189
task MYHDL141_adv;
190
    input width;
191
    integer width;
192
    integer nshift;
193
begin: MYHDL217_RETURN
194
    nshift = ((deflate0_0_dio + width) >>> 3);
195
    o_iprogress <= deflate0_0_di;
196
    deflate0_0_dio <= ((deflate0_0_dio + width) & 7);
197
    deflate0_0_di <= ($signed({1'b0, deflate0_0_di}) + nshift);
198
    if ((nshift != 0)) begin
199
        deflate0_0_filled <= 1'b0;
200
    end
201
end
202
endtask
203
 
204
function integer MYHDL142_get4;
205
    input boffset;
206
    input width;
207
begin: MYHDL218_RETURN
208
    if ((deflate0_0_nb != 4)) begin
209
        $write("----NB----");
210
        $write("\n");
211
        $finish;
212
    end
213
    MYHDL142_get4 = ((deflate0_0_b41 >>> (deflate0_0_dio + boffset)) & ((1 << width) - 1));
214
    disable MYHDL218_RETURN;
215
end
216
endfunction
217
 
218
function integer MYHDL143_get4;
219
    input boffset;
220
    input width;
221
    integer width;
222
begin: MYHDL219_RETURN
223
    if ((deflate0_0_nb != 4)) begin
224
        $write("----NB----");
225
        $write("\n");
226
        $finish;
227
    end
228
    MYHDL143_get4 = ((deflate0_0_b41 >>> (deflate0_0_dio + boffset)) & ((1 << width) - 1));
229
    disable MYHDL219_RETURN;
230
end
231
endfunction
232
 
233
task MYHDL144_adv;
234
    input width;
235
    integer width;
236
    integer nshift;
237
begin: MYHDL220_RETURN
238
    nshift = ((deflate0_0_dio + width) >>> 3);
239
    o_iprogress <= deflate0_0_di;
240
    deflate0_0_dio <= ((deflate0_0_dio + width) & 7);
241
    deflate0_0_di <= ($signed({1'b0, deflate0_0_di}) + nshift);
242
    if ((nshift != 0)) begin
243
        deflate0_0_filled <= 1'b0;
244
    end
245
end
246
endtask
247
 
248
task MYHDL145_adv;
249
    input width;
250
    integer width;
251
    integer nshift;
252
begin: MYHDL221_RETURN
253
    nshift = ((deflate0_0_dio + width) >>> 3);
254
    o_iprogress <= deflate0_0_di;
255
    deflate0_0_dio <= ((deflate0_0_dio + width) & 7);
256
    deflate0_0_di <= ($signed({1'b0, deflate0_0_di}) + nshift);
257
    if ((nshift != 0)) begin
258
        deflate0_0_filled <= 1'b0;
259
    end
260
end
261
endtask
262
 
263
function integer MYHDL146_get4;
264
    input boffset;
265
    integer boffset;
266
    input width;
267
    integer width;
268
begin: MYHDL222_RETURN
269
    if ((deflate0_0_nb != 4)) begin
270
        $write("----NB----");
271
        $write("\n");
272
        $finish;
273
    end
274
    MYHDL146_get4 = ($signed($signed({1'b0, deflate0_0_b41}) >>> ($signed({1'b0, deflate0_0_dio}) + boffset)) & ((1 << width) - 1));
275
    disable MYHDL222_RETURN;
276
end
277
endfunction
278
 
279
task MYHDL147_adv;
280
    input width;
281
    integer width;
282
    integer nshift;
283
begin: MYHDL223_RETURN
284
    nshift = $signed(($signed({1'b0, deflate0_0_dio}) + width) >>> 3);
285
    o_iprogress <= deflate0_0_di;
286
    deflate0_0_dio <= (($signed({1'b0, deflate0_0_dio}) + width) & 7);
287
    deflate0_0_di <= ($signed({1'b0, deflate0_0_di}) + nshift);
288
    if ((nshift != 0)) begin
289
        deflate0_0_filled <= 1'b0;
290
    end
291
end
292
endtask
293
 
294
function integer MYHDL148_put;
295
    input d;
296
    integer d;
297
    input width;
298
    integer width;
299
begin: MYHDL224_RETURN
300
    if ((width > 9)) begin
301
        $finish;
302
    end
303
    if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
304
        $finish;
305
    end
306
    MYHDL148_put = ((deflate0_0_ob1 | (d << deflate0_0_doo)) & 255);
307
    disable MYHDL224_RETURN;
308
end
309
endfunction
310
 
311
task MYHDL149_put_adv;
312
    input d;
313
    integer d;
314
    input width;
315
    integer width;
316
    reg pshift;
317
    integer carry;
318
    integer doo_next;
319
begin: MYHDL225_RETURN
320
    if ((width > 9)) begin
321
        $finish;
322
    end
323
    if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
324
        $finish;
325
    end
326
    pshift = ((deflate0_0_doo + width) > 8);
327
    if (pshift) begin
328
        carry = ($signed({1'b0, width}) - (8 - $signed({1'b0, deflate0_0_doo})));
329
        deflate0_0_ob1 <= $signed($signed({1'b0, d}) >>> ($signed({1'b0, width}) - carry));
330
    end
331
    else begin
332
        deflate0_0_ob1 <= (deflate0_0_ob1 | (d << deflate0_0_doo));
333
    end
334
    deflate0_0_do <= (deflate0_0_do + pshift);
335
    o_oprogress <= (deflate0_0_do + pshift);
336
    doo_next = ((deflate0_0_doo + width) & 7);
337
    if ((doo_next == 0)) begin
338
        deflate0_0_flush <= 1'b1;
339
    end
340
    deflate0_0_doo <= doo_next;
341
end
342
endtask
343
 
344
task MYHDL150_do_flush;
345
begin: MYHDL226_RETURN
346
    deflate0_0_flush <= 1'b0;
347
    deflate0_0_ob1 <= 0;
348
    o_oprogress <= (deflate0_0_do + 1);
349
    deflate0_0_do <= (deflate0_0_do + 1);
350
end
351
endtask
352
 
353
function integer MYHDL151_put;
354
    input [9-1:0] d;
355
    input [4-1:0] width;
356
begin: MYHDL227_RETURN
357
    if ((width > 9)) begin
358
        $finish;
359
    end
360
    if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
361
        $finish;
362
    end
363
    MYHDL151_put = ((deflate0_0_ob1 | (d << deflate0_0_doo)) & 255);
364
    disable MYHDL227_RETURN;
365
end
366
endfunction
367
 
368
task MYHDL152_put_adv;
369
    input [9-1:0] d;
370
    input [4-1:0] width;
371
    reg pshift;
372
    integer carry;
373
    integer doo_next;
374
begin: MYHDL228_RETURN
375
    if ((width > 9)) begin
376
        $finish;
377
    end
378
    if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
379
        $finish;
380
    end
381
    pshift = ((deflate0_0_doo + width) > 8);
382
    if (pshift) begin
383
        carry = ($signed({1'b0, width}) - (8 - $signed({1'b0, deflate0_0_doo})));
384
        deflate0_0_ob1 <= $signed($signed({1'b0, d}) >>> ($signed({1'b0, width}) - carry));
385
    end
386
    else begin
387
        deflate0_0_ob1 <= (deflate0_0_ob1 | (d << deflate0_0_doo));
388
    end
389
    deflate0_0_do <= (deflate0_0_do + pshift);
390
    o_oprogress <= (deflate0_0_do + pshift);
391
    doo_next = ((deflate0_0_doo + width) & 7);
392
    if ((doo_next == 0)) begin
393
        deflate0_0_flush <= 1'b1;
394
    end
395
    deflate0_0_doo <= doo_next;
396
end
397
endtask
398
 
399
task MYHDL153_do_flush;
400
begin: MYHDL229_RETURN
401
    deflate0_0_flush <= 1'b0;
402
    deflate0_0_ob1 <= 0;
403
    o_oprogress <= (deflate0_0_do + 1);
404
    deflate0_0_do <= (deflate0_0_do + 1);
405
end
406
endtask
407
 
408
function integer MYHDL154_rev_bits;
409
    input [13-1:0] b;
410
    input nb;
411
    integer nb;
412
    integer r;
413
begin: MYHDL230_RETURN
414
    if ((b >= (1 << nb))) begin
415
        $finish;
416
        $write("too few bits");
417
        $write("\n");
418
    end
419
    r = (((((((((((((((((b >>> 14) & 1) << 0) | (((b >>> 13) & 1) << 1)) | (((b >>> 12) & 1) << 2)) | (((b >>> 11) & 1) << 3)) | (((b >>> 10) & 1) << 4)) | (((b >>> 9) & 1) << 5)) | (((b >>> 8) & 1) << 6)) | (((b >>> 7) & 1) << 7)) | (((b >>> 6) & 1) << 8)) | (((b >>> 5) & 1) << 9)) | (((b >>> 4) & 1) << 10)) | (((b >>> 3) & 1) << 11)) | (((b >>> 2) & 1) << 12)) | (((b >>> 1) & 1) << 13)) | (((b >>> 0) & 1) << 14));
420
    r = r >>> (15 - $signed({1'b0, nb}));
421
    MYHDL154_rev_bits = r;
422
    disable MYHDL230_RETURN;
423
end
424
endfunction
425
 
426
function integer MYHDL155_put;
427
    input d;
428
    integer d;
429
    input width;
430
    integer width;
431
begin: MYHDL231_RETURN
432
    if ((width > 9)) begin
433
        $finish;
434
    end
435
    if ((d > ((1 << width) - 1))) begin
436
        $finish;
437
    end
438
    MYHDL155_put = (($signed({1'b0, deflate0_0_ob1}) | (d << $signed({1'b0, deflate0_0_doo}))) & 255);
439
    disable MYHDL231_RETURN;
440
end
441
endfunction
442
 
443
task MYHDL156_put_adv;
444
    input d;
445
    integer d;
446
    input width;
447
    integer width;
448
    reg pshift;
449
    integer carry;
450
    integer doo_next;
451
begin: MYHDL232_RETURN
452
    if ((width > 9)) begin
453
        $finish;
454
    end
455
    if ((d > ((1 << width) - 1))) begin
456
        $finish;
457
    end
458
    pshift = (($signed({1'b0, deflate0_0_doo}) + width) > 8);
459
    if (pshift) begin
460
        carry = (width - (8 - $signed({1'b0, deflate0_0_doo})));
461
        deflate0_0_ob1 <= $signed(d >>> (width - carry));
462
    end
463
    else begin
464
        deflate0_0_ob1 <= ($signed({1'b0, deflate0_0_ob1}) | (d << $signed({1'b0, deflate0_0_doo})));
465
    end
466
    deflate0_0_do <= (deflate0_0_do + pshift);
467
    o_oprogress <= (deflate0_0_do + pshift);
468
    doo_next = (($signed({1'b0, deflate0_0_doo}) + width) & 7);
469
    if ((doo_next == 0)) begin
470
        deflate0_0_flush <= 1'b1;
471
    end
472
    deflate0_0_doo <= doo_next;
473
end
474
endtask
475
 
476
function integer MYHDL157_put;
477
    input [9-1:0] d;
478
    input [4-1:0] width;
479
begin: MYHDL233_RETURN
480
    if ((width > 9)) begin
481
        $finish;
482
    end
483
    if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
484
        $finish;
485
    end
486
    MYHDL157_put = ((deflate0_0_ob1 | (d << deflate0_0_doo)) & 255);
487
    disable MYHDL233_RETURN;
488
end
489
endfunction
490
 
491
task MYHDL158_put_adv;
492
    input [9-1:0] d;
493
    input [4-1:0] width;
494
    reg pshift;
495
    integer carry;
496
    integer doo_next;
497
begin: MYHDL234_RETURN
498
    if ((width > 9)) begin
499
        $finish;
500
    end
501
    if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
502
        $finish;
503
    end
504
    pshift = ((deflate0_0_doo + width) > 8);
505
    if (pshift) begin
506
        carry = ($signed({1'b0, width}) - (8 - $signed({1'b0, deflate0_0_doo})));
507
        deflate0_0_ob1 <= $signed($signed({1'b0, d}) >>> ($signed({1'b0, width}) - carry));
508
    end
509
    else begin
510
        deflate0_0_ob1 <= (deflate0_0_ob1 | (d << deflate0_0_doo));
511
    end
512
    deflate0_0_do <= (deflate0_0_do + pshift);
513
    o_oprogress <= (deflate0_0_do + pshift);
514
    doo_next = ((deflate0_0_doo + width) & 7);
515
    if ((doo_next == 0)) begin
516
        deflate0_0_flush <= 1'b1;
517
    end
518
    deflate0_0_doo <= doo_next;
519
end
520
endtask
521
 
522
function integer MYHDL159_put;
523
    input [9-1:0] d;
524
    input [4-1:0] width;
525
begin: MYHDL235_RETURN
526
    if ((width > 9)) begin
527
        $finish;
528
    end
529
    if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
530
        $finish;
531
    end
532
    MYHDL159_put = ((deflate0_0_ob1 | (d << deflate0_0_doo)) & 255);
533
    disable MYHDL235_RETURN;
534
end
535
endfunction
536
 
537
task MYHDL160_put_adv;
538
    input [9-1:0] d;
539
    input [4-1:0] width;
540
    reg pshift;
541
    integer carry;
542
    integer doo_next;
543
begin: MYHDL236_RETURN
544
    if ((width > 9)) begin
545
        $finish;
546
    end
547
    if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
548
        $finish;
549
    end
550
    pshift = ((deflate0_0_doo + width) > 8);
551
    if (pshift) begin
552
        carry = ($signed({1'b0, width}) - (8 - $signed({1'b0, deflate0_0_doo})));
553
        deflate0_0_ob1 <= $signed($signed({1'b0, d}) >>> ($signed({1'b0, width}) - carry));
554
    end
555
    else begin
556
        deflate0_0_ob1 <= (deflate0_0_ob1 | (d << deflate0_0_doo));
557
    end
558
    deflate0_0_do <= (deflate0_0_do + pshift);
559
    o_oprogress <= (deflate0_0_do + pshift);
560
    doo_next = ((deflate0_0_doo + width) & 7);
561
    if ((doo_next == 0)) begin
562
        deflate0_0_flush <= 1'b1;
563
    end
564
    deflate0_0_doo <= doo_next;
565
end
566
endtask
567
 
568
function integer MYHDL169_get4;
569
    input boffset;
570
    input width;
571
    integer width;
572
begin: MYHDL237_RETURN
573
    if ((deflate0_0_nb != 4)) begin
574
        $write("----NB----");
575
        $write("\n");
576
        $finish;
577
    end
578
    MYHDL169_get4 = ((deflate0_0_b41 >>> (deflate0_0_dio + boffset)) & ((1 << width) - 1));
579
    disable MYHDL237_RETURN;
580
end
581
endfunction
582
 
583
function integer MYHDL170_get4;
584
    input boffset;
585
    input width;
586
    integer width;
587
begin: MYHDL238_RETURN
588
    if ((deflate0_0_nb != 4)) begin
589
        $write("----NB----");
590
        $write("\n");
591
        $finish;
592
    end
593
    MYHDL170_get4 = ((deflate0_0_b41 >>> (deflate0_0_dio + boffset)) & ((1 << width) - 1));
594
    disable MYHDL238_RETURN;
595
end
596
endfunction
597
 
598
function integer MYHDL171_get4;
599
    input boffset;
600
    integer boffset;
601
    input width;
602
    integer width;
603
begin: MYHDL239_RETURN
604
    if ((deflate0_0_nb != 4)) begin
605
        $write("----NB----");
606
        $write("\n");
607
        $finish;
608
    end
609
    MYHDL171_get4 = ((deflate0_0_b41 >>> (deflate0_0_dio + boffset)) & ((1 << width) - 1));
610
    disable MYHDL239_RETURN;
611
end
612
endfunction
613
 
614
function integer MYHDL172_get4;
615
    input boffset;
616
    integer boffset;
617
    input width;
618
    integer width;
619
begin: MYHDL240_RETURN
620
    if ((deflate0_0_nb != 4)) begin
621
        $write("----NB----");
622
        $write("\n");
623
        $finish;
624
    end
625
    MYHDL172_get4 = ((deflate0_0_b41 >>> (deflate0_0_dio + boffset)) & ((1 << width) - 1));
626
    disable MYHDL240_RETURN;
627
end
628
endfunction
629
 
630
function integer MYHDL173_get4;
631
    input boffset;
632
    integer boffset;
633
    input width;
634
    integer width;
635
begin: MYHDL241_RETURN
636
    if ((deflate0_0_nb != 4)) begin
637
        $write("----NB----");
638
        $write("\n");
639
        $finish;
640
    end
641
    MYHDL173_get4 = ((deflate0_0_b41 >>> (deflate0_0_dio + boffset)) & ((1 << width) - 1));
642
    disable MYHDL241_RETURN;
643
end
644
endfunction
645
 
646
function integer MYHDL174_get4;
647
    input boffset;
648
    integer boffset;
649
    input width;
650
    integer width;
651
begin: MYHDL242_RETURN
652
    if ((deflate0_0_nb != 4)) begin
653
        $write("----NB----");
654
        $write("\n");
655
        $finish;
656
    end
657
    MYHDL174_get4 = ((deflate0_0_b41 >>> (deflate0_0_dio + boffset)) & ((1 << width) - 1));
658
    disable MYHDL242_RETURN;
659
end
660
endfunction
661
 
662
task MYHDL175_adv;
663
    input width;
664
    integer width;
665
    integer nshift;
666
begin: MYHDL243_RETURN
667
    nshift = ((deflate0_0_dio + width) >>> 3);
668
    o_iprogress <= deflate0_0_di;
669
    deflate0_0_dio <= ((deflate0_0_dio + width) & 7);
670
    deflate0_0_di <= ($signed({1'b0, deflate0_0_di}) + nshift);
671
    if ((nshift != 0)) begin
672
        deflate0_0_filled <= 1'b0;
673
    end
674
end
675
endtask
676
 
677
function integer MYHDL176_get4;
678
    input boffset;
679
    input width;
680
    integer width;
681
begin: MYHDL244_RETURN
682
    if ((deflate0_0_nb != 4)) begin
683
        $write("----NB----");
684
        $write("\n");
685
        $finish;
686
    end
687
    MYHDL176_get4 = ((deflate0_0_b41 >>> (deflate0_0_dio + boffset)) & ((1 << width) - 1));
688
    disable MYHDL244_RETURN;
689
end
690
endfunction
691
 
692
task MYHDL177_adv;
693
    input width;
694
    integer width;
695
    integer nshift;
696
begin: MYHDL245_RETURN
697
    nshift = ((deflate0_0_dio + width) >>> 3);
698
    o_iprogress <= deflate0_0_di;
699
    deflate0_0_dio <= ((deflate0_0_dio + width) & 7);
700
    deflate0_0_di <= ($signed({1'b0, deflate0_0_di}) + nshift);
701
    if ((nshift != 0)) begin
702
        deflate0_0_filled <= 1'b0;
703
    end
704
end
705
endtask
706
 
707
function integer MYHDL178_get4;
708
    input boffset;
709
    input width;
710
    integer width;
711
begin: MYHDL246_RETURN
712
    if ((deflate0_0_nb != 4)) begin
713
        $write("----NB----");
714
        $write("\n");
715
        $finish;
716
    end
717
    MYHDL178_get4 = ((deflate0_0_b41 >>> (deflate0_0_dio + boffset)) & ((1 << width) - 1));
718
    disable MYHDL246_RETURN;
719
end
720
endfunction
721
 
722
function integer MYHDL179_get4;
723
    input boffset;
724
    input width;
725
    integer width;
726
begin: MYHDL247_RETURN
727
    if ((deflate0_0_nb != 4)) begin
728
        $write("----NB----");
729
        $write("\n");
730
        $finish;
731
    end
732
    MYHDL179_get4 = ((deflate0_0_b41 >>> (deflate0_0_dio + boffset)) & ((1 << width) - 1));
733
    disable MYHDL247_RETURN;
734
end
735
endfunction
736
 
737
function integer MYHDL180_get4;
738
    input boffset;
739
    input width;
740
    integer width;
741
begin: MYHDL248_RETURN
742
    if ((deflate0_0_nb != 4)) begin
743
        $write("----NB----");
744
        $write("\n");
745
        $finish;
746
    end
747
    MYHDL180_get4 = ((deflate0_0_b41 >>> (deflate0_0_dio + boffset)) & ((1 << width) - 1));
748
    disable MYHDL248_RETURN;
749
end
750
endfunction
751
 
752
task MYHDL181_adv;
753
    input width;
754
    integer width;
755
    integer nshift;
756
begin: MYHDL249_RETURN
757
    nshift = ((deflate0_0_dio + width) >>> 3);
758
    o_iprogress <= deflate0_0_di;
759
    deflate0_0_dio <= ((deflate0_0_dio + width) & 7);
760
    deflate0_0_di <= ($signed({1'b0, deflate0_0_di}) + nshift);
761
    if ((nshift != 0)) begin
762
        deflate0_0_filled <= 1'b0;
763
    end
764
end
765
endtask
766
 
767
function integer MYHDL188_rev_bits;
768
    input [10-1:0] b;
769
    input [4-1:0] nb;
770
    integer r;
771
begin: MYHDL250_RETURN
772
    if ((b >= (1 << nb))) begin
773
        $finish;
774
        $write("too few bits");
775
        $write("\n");
776
    end
777
    r = (((((((((((((((((b >>> 14) & 1) << 0) | (((b >>> 13) & 1) << 1)) | (((b >>> 12) & 1) << 2)) | (((b >>> 11) & 1) << 3)) | (((b >>> 10) & 1) << 4)) | (((b >>> 9) & 1) << 5)) | (((b >>> 8) & 1) << 6)) | (((b >>> 7) & 1) << 7)) | (((b >>> 6) & 1) << 8)) | (((b >>> 5) & 1) << 9)) | (((b >>> 4) & 1) << 10)) | (((b >>> 3) & 1) << 11)) | (((b >>> 2) & 1) << 12)) | (((b >>> 1) & 1) << 13)) | (((b >>> 0) & 1) << 14));
778
    r = r >>> (15 - $signed({1'b0, nb}));
779
    MYHDL188_rev_bits = r;
780
    disable MYHDL250_RETURN;
781
end
782
endfunction
783
 
784
function integer MYHDL189_makeLeaf;
785
    input [9-1:0] lcode;
786
    input [4-1:0] lbits;
787
begin: MYHDL251_RETURN
788
    if ((lcode >= (1 << 10))) begin
789
        $finish;
790
    end
791
    if ((lbits >= (1 << 9))) begin
792
        $finish;
793
    end
794
    MYHDL189_makeLeaf = ((lcode << 9) | lbits);
795
    disable MYHDL251_RETURN;
796
end
797
endfunction
798
 
799
function integer MYHDL190_makeLeaf;
800
    input [9-1:0] lcode;
801
    input [4-1:0] lbits;
802
begin: MYHDL252_RETURN
803
    if ((lcode >= (1 << 10))) begin
804
        $finish;
805
    end
806
    if ((lbits >= (1 << 9))) begin
807
        $finish;
808
    end
809
    MYHDL190_makeLeaf = ((lcode << 9) | lbits);
810
    disable MYHDL252_RETURN;
811
end
812
endfunction
813
 
814
function integer MYHDL191_makeLeaf;
815
    input [9-1:0] lcode;
816
    input [4-1:0] lbits;
817
begin: MYHDL253_RETURN
818
    if ((lcode >= (1 << 10))) begin
819
        $finish;
820
    end
821
    if ((lbits >= (1 << 9))) begin
822
        $finish;
823
    end
824
    MYHDL191_makeLeaf = ((lcode << 9) | lbits);
825
    disable MYHDL253_RETURN;
826
end
827
endfunction
828
 
829
function integer MYHDL192_get4;
830
    input boffset;
831
    input [5-1:0] width;
832
begin: MYHDL254_RETURN
833
    if ((deflate0_0_nb != 4)) begin
834
        $write("----NB----");
835
        $write("\n");
836
        $finish;
837
    end
838
    MYHDL192_get4 = ((deflate0_0_b41 >>> (deflate0_0_dio + boffset)) & ((1 << width) - 1));
839
    disable MYHDL254_RETURN;
840
end
841
endfunction
842
 
843
function integer MYHDL193_get_bits;
844
    input [19-1:0] aleaf;
845
begin: MYHDL255_RETURN
846
    MYHDL193_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
847
    disable MYHDL255_RETURN;
848
end
849
endfunction
850
 
851
function integer MYHDL194_get_bits;
852
    input [19-1:0] aleaf;
853
begin: MYHDL256_RETURN
854
    MYHDL194_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
855
    disable MYHDL256_RETURN;
856
end
857
endfunction
858
 
859
task MYHDL195_adv;
860
    input width;
861
    integer width;
862
    integer nshift;
863
begin: MYHDL257_RETURN
864
    nshift = $signed(($signed({1'b0, deflate0_0_dio}) + width) >>> 3);
865
    o_iprogress <= deflate0_0_di;
866
    deflate0_0_dio <= (($signed({1'b0, deflate0_0_dio}) + width) & 7);
867
    deflate0_0_di <= ($signed({1'b0, deflate0_0_di}) + nshift);
868
    if ((nshift != 0)) begin
869
        deflate0_0_filled <= 1'b0;
870
    end
871
end
872
endtask
873
 
874
function integer MYHDL196_get_code;
875
    input [19-1:0] aleaf;
876
begin: MYHDL258_RETURN
877
    MYHDL196_get_code = (aleaf >>> 9);
878
    disable MYHDL258_RETURN;
879
end
880
endfunction
881
 
882
function integer MYHDL197_get_code;
883
    input [19-1:0] aleaf;
884
begin: MYHDL259_RETURN
885
    MYHDL197_get_code = (aleaf >>> 9);
886
    disable MYHDL259_RETURN;
887
end
888
endfunction
889
 
890
function integer MYHDL198_get4;
891
    input boffset;
892
    integer boffset;
893
    input [5-1:0] width;
894
begin: MYHDL260_RETURN
895
    if ((deflate0_0_nb != 4)) begin
896
        $write("----NB----");
897
        $write("\n");
898
        $finish;
899
    end
900
    MYHDL198_get4 = ($signed($signed({1'b0, deflate0_0_b41}) >>> ($signed({1'b0, deflate0_0_dio}) + boffset)) & ((1 << width) - 1));
901
    disable MYHDL260_RETURN;
902
end
903
endfunction
904
 
905
function integer MYHDL199_get_bits;
906
    input [19-1:0] aleaf;
907
begin: MYHDL261_RETURN
908
    MYHDL199_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
909
    disable MYHDL261_RETURN;
910
end
911
endfunction
912
 
913
function integer MYHDL200_get4;
914
    input boffset;
915
    input width;
916
    integer width;
917
begin: MYHDL262_RETURN
918
    if ((deflate0_0_nb != 4)) begin
919
        $write("----NB----");
920
        $write("\n");
921
        $finish;
922
    end
923
    MYHDL200_get4 = ((deflate0_0_b41 >>> (deflate0_0_dio + boffset)) & ((1 << width) - 1));
924
    disable MYHDL262_RETURN;
925
end
926
endfunction
927
 
928
function integer MYHDL201_get_code;
929
    input [19-1:0] aleaf;
930
begin: MYHDL263_RETURN
931
    MYHDL201_get_code = (aleaf >>> 9);
932
    disable MYHDL263_RETURN;
933
end
934
endfunction
935
 
936
function integer MYHDL202_get_bits;
937
    input [19-1:0] aleaf;
938
begin: MYHDL264_RETURN
939
    MYHDL202_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
940
    disable MYHDL264_RETURN;
941
end
942
endfunction
943
 
944
function integer MYHDL203_get4;
945
    input boffset;
946
    integer boffset;
947
    input width;
948
    integer width;
949
begin: MYHDL265_RETURN
950
    if ((deflate0_0_nb != 4)) begin
951
        $write("----NB----");
952
        $write("\n");
953
        $finish;
954
    end
955
    MYHDL203_get4 = ($signed($signed({1'b0, deflate0_0_b41}) >>> ($signed({1'b0, deflate0_0_dio}) + boffset)) & ((1 << width) - 1));
956
    disable MYHDL265_RETURN;
957
end
958
endfunction
959
 
960
function integer MYHDL204_get_bits;
961
    input [19-1:0] aleaf;
962
begin: MYHDL266_RETURN
963
    MYHDL204_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
964
    disable MYHDL266_RETURN;
965
end
966
endfunction
967
 
968
task MYHDL205_adv;
969
    input width;
970
    integer width;
971
    integer nshift;
972
begin: MYHDL267_RETURN
973
    nshift = $signed(($signed({1'b0, deflate0_0_dio}) + width) >>> 3);
974
    o_iprogress <= deflate0_0_di;
975
    deflate0_0_dio <= (($signed({1'b0, deflate0_0_dio}) + width) & 7);
976
    deflate0_0_di <= ($signed({1'b0, deflate0_0_di}) + nshift);
977
    if ((nshift != 0)) begin
978
        deflate0_0_filled <= 1'b0;
979
    end
980
end
981
endtask
982
 
983
function integer MYHDL206_get4;
984
    input boffset;
985
    input width;
986
    integer width;
987
begin: MYHDL268_RETURN
988
    if ((deflate0_0_nb != 4)) begin
989
        $write("----NB----");
990
        $write("\n");
991
        $finish;
992
    end
993
    MYHDL206_get4 = ((deflate0_0_b41 >>> (deflate0_0_dio + boffset)) & ((1 << width) - 1));
994
    disable MYHDL268_RETURN;
995
end
996
endfunction
997
 
998
function integer MYHDL207_get4;
999
    input boffset;
1000
    integer boffset;
1001
    input width;
1002
    integer width;
1003
begin: MYHDL269_RETURN
1004
    if ((deflate0_0_nb != 4)) begin
1005
        $write("----NB----");
1006
        $write("\n");
1007
        $finish;
1008
    end
1009
    MYHDL207_get4 = ($signed($signed({1'b0, deflate0_0_b41}) >>> ($signed({1'b0, deflate0_0_dio}) + boffset)) & ((1 << width) - 1));
1010
    disable MYHDL269_RETURN;
1011
end
1012
endfunction
1013
 
1014
function integer MYHDL208_rev_bits;
1015
    input b;
1016
    integer b;
1017
    input nb;
1018
    integer nb;
1019
    integer r;
1020
begin: MYHDL270_RETURN
1021
    if ((b >= (1 << nb))) begin
1022
        $finish;
1023
        $write("too few bits");
1024
        $write("\n");
1025
    end
1026
    r = (((((((((((((((((b >>> 14) & 1) << 0) | (((b >>> 13) & 1) << 1)) | (((b >>> 12) & 1) << 2)) | (((b >>> 11) & 1) << 3)) | (((b >>> 10) & 1) << 4)) | (((b >>> 9) & 1) << 5)) | (((b >>> 8) & 1) << 6)) | (((b >>> 7) & 1) << 7)) | (((b >>> 6) & 1) << 8)) | (((b >>> 5) & 1) << 9)) | (((b >>> 4) & 1) << 10)) | (((b >>> 3) & 1) << 11)) | (((b >>> 2) & 1) << 12)) | (((b >>> 1) & 1) << 13)) | (((b >>> 0) & 1) << 14));
1027
    r = r >>> (15 - $signed({1'b0, nb}));
1028
    MYHDL208_rev_bits = r;
1029
    disable MYHDL270_RETURN;
1030
end
1031
endfunction
1032
 
1033
function integer MYHDL209_get4;
1034
    input boffset;
1035
    integer boffset;
1036
    input width;
1037
    integer width;
1038
begin: MYHDL271_RETURN
1039
    if ((deflate0_0_nb != 4)) begin
1040
        $write("----NB----");
1041
        $write("\n");
1042
        $finish;
1043
    end
1044
    MYHDL209_get4 = ($signed($signed({1'b0, deflate0_0_b41}) >>> ($signed({1'b0, deflate0_0_dio}) + boffset)) & ((1 << width) - 1));
1045
    disable MYHDL271_RETURN;
1046
end
1047
endfunction
1048
 
1049
task MYHDL210_adv;
1050
    input width;
1051
    integer width;
1052
    integer nshift;
1053
begin: MYHDL272_RETURN
1054
    nshift = $signed(($signed({1'b0, deflate0_0_dio}) + width) >>> 3);
1055
    o_iprogress <= deflate0_0_di;
1056
    deflate0_0_dio <= (($signed({1'b0, deflate0_0_dio}) + width) & 7);
1057
    deflate0_0_di <= ($signed({1'b0, deflate0_0_di}) + nshift);
1058
    if ((nshift != 0)) begin
1059
        deflate0_0_filled <= 1'b0;
1060
    end
1061
end
1062
endtask
1063
 
1064
task MYHDL211_adv;
1065
    input width;
1066
    integer width;
1067
    integer nshift;
1068
begin: MYHDL273_RETURN
1069
    nshift = ((deflate0_0_dio + width) >>> 3);
1070
    o_iprogress <= deflate0_0_di;
1071
    deflate0_0_dio <= ((deflate0_0_dio + width) & 7);
1072
    deflate0_0_di <= ($signed({1'b0, deflate0_0_di}) + nshift);
1073
    if ((nshift != 0)) begin
1074
        deflate0_0_filled <= 1'b0;
1075
    end
1076
end
1077
endtask
1078
 
1079
 
1080
initial begin: TEST_FAST_BENCH_CLKGEN
1081
    i_clk <= 0;
1082
    while (1'b1) begin
1083
        # 5;
1084
        i_clk <= (!i_clk);
1085
    end
1086
end
1087
 
1088
 
1089
always @(posedge i_clk) begin: TEST_FAST_BENCH_DEFLATE0_0_IO_LOGIC
1090
    case (i_mode)
1091
        'h2: begin
1092
            deflate0_0_iram[(i_addr & 127)] <= i_data;
1093
            deflate0_0_isize <= i_addr;
1094
        end
1095
        'h3: begin
1096
            o_byte <= deflate0_0_oram[i_addr];
1097
        end
1098
        default: begin
1099
            // pass
1100
        end
1101
    endcase
1102
end
1103
 
1104
 
1105
always @(posedge i_clk) begin: TEST_FAST_BENCH_DEFLATE0_0_LOGIC
1106
    integer hm;
1107
    integer skip;
1108
    reg no_adv;
1109
    integer cs_i;
1110
    reg [4-1:0] outlen;
1111
    reg [9-1:0] outbits;
1112
    reg [8-1:0] bdata;
1113
    integer adler1_next;
1114
    integer nextdist;
1115
    integer copydist;
1116
    integer extra_dist;
1117
    integer extra_bits;
1118
    integer outcode;
1119
    integer lencode;
1120
    integer match;
1121
    integer distance;
1122
    integer stat_i;
1123
    integer clo_i;
1124
    integer n_adv;
1125
    integer dbl_i;
1126
    integer dbl;
1127
    integer dist_i;
1128
    integer limit;
1129
    reg [4-1:0] j;
1130
    integer t;
1131
    integer hf2_i;
1132
    reg [5-1:0] amb;
1133
    integer ncode;
1134
    reg [10-1:0] canonical;
1135
    reg [4-1:0] bits_next;
1136
    reg [15-1:0] aim;
1137
    integer cto;
1138
    integer mask;
1139
    integer token;
1140
    integer extraLength;
1141
    integer tlength;
1142
    integer distanceCode;
1143
    integer moreBits;
1144
    integer mored;
1145
    if ((!reset)) begin
1146
        $write("DEFLATE RESET");
1147
        $write("\n");
1148
        deflate0_0_state <= 5'b00000;
1149
        o_done <= 1'b0;
1150
    end
1151
    else begin
1152
        case (deflate0_0_state)
1153
            5'b00000: begin
1154
                case (i_mode)
1155
                    'h4: begin
1156
                        $write("STARTC");
1157
                        $write("\n");
1158
                        deflate0_0_do_compress <= 1'b1;
1159
                        deflate0_0_method <= 1;
1160
                        o_done <= 1'b0;
1161
                        o_iprogress <= 0;
1162
                        o_oprogress <= 0;
1163
                        deflate0_0_di <= 0;
1164
                        deflate0_0_dio <= 0;
1165
                        deflate0_0_do <= 0;
1166
                        deflate0_0_doo <= 0;
1167
                        deflate0_0_filled <= 1'b1;
1168
                        deflate0_0_cur_static <= 0;
1169
                        deflate0_0_state <= 5'b01110;
1170
                    end
1171
                    'h5: begin
1172
                        deflate0_0_do_compress <= 1'b0;
1173
                        o_done <= 1'b0;
1174
                        o_iprogress <= 0;
1175
                        o_oprogress <= 0;
1176
                        deflate0_0_di <= 0;
1177
                        deflate0_0_dio <= 0;
1178
                        deflate0_0_do <= 0;
1179
                        deflate0_0_doo <= 0;
1180
                        deflate0_0_filled <= 1'b1;
1181
                        deflate0_0_state <= 5'b00001;
1182
                    end
1183
                    default: begin
1184
                        // pass
1185
                    end
1186
                endcase
1187
            end
1188
            5'b00001: begin
1189
                if ((!deflate0_0_filled)) begin
1190
                    deflate0_0_filled <= 1'b1;
1191
                end
1192
                else if ((deflate0_0_nb < 4)) begin
1193
                    // pass
1194
                end
1195
                else if ((deflate0_0_di == 0)) begin
1196
                    if ((deflate0_0_b1 == 120)) begin
1197
                        $write("deflate mode");
1198
                        $write("\n");
1199
                    end
1200
                    else begin
1201
                        $write("%h", deflate0_0_di);
1202
                        $write(" ");
1203
                        $write("%h", deflate0_0_dio);
1204
                        $write(" ");
1205
                        $write("%h", deflate0_0_nb);
1206
                        $write(" ");
1207
                        $write("%h", deflate0_0_b1);
1208
                        $write(" ");
1209
                        $write("%h", deflate0_0_b2);
1210
                        $write(" ");
1211
                        $write("%h", deflate0_0_b3);
1212
                        $write(" ");
1213
                        $write("%h", deflate0_0_b4);
1214
                        $write(" ");
1215
                        $write("%h", deflate0_0_isize);
1216
                        $write("\n");
1217
                        $finish;
1218
                        o_done <= 1'b1;
1219
                        deflate0_0_state <= 5'b00000;
1220
                    end
1221
                    MYHDL141_adv(16);
1222
                end
1223
                else begin
1224
                    if (MYHDL142_get4(0, 1)) begin
1225
                        $write("final");
1226
                        $write("\n");
1227
                        deflate0_0_final <= 1'b1;
1228
                    end
1229
                    hm = MYHDL143_get4(1, 2);
1230
                    deflate0_0_method <= hm;
1231
                    $write("method");
1232
                    $write(" ");
1233
                    $write("%0d", hm);
1234
                    $write("\n");
1235
                    case (hm)
1236
                        'h2: begin
1237
                            deflate0_0_state <= 5'b00010;
1238
                            deflate0_0_numCodeLength <= 0;
1239
                            deflate0_0_numLiterals <= 0;
1240
                            deflate0_0_static <= 1'b0;
1241
                            MYHDL144_adv(3);
1242
                        end
1243
                        'h1: begin
1244
                            deflate0_0_static <= 1'b1;
1245
                            deflate0_0_cur_static <= 0;
1246
                            deflate0_0_state <= 5'b01110;
1247
                            MYHDL145_adv(3);
1248
                        end
1249
                        'h0: begin
1250
                            deflate0_0_state <= 5'b10101;
1251
                            skip = (8 - deflate0_0_dio);
1252
                            if ((skip <= 2)) begin
1253
                                skip = (16 - deflate0_0_dio);
1254
                            end
1255
                            deflate0_0_length <= MYHDL146_get4(skip, 16);
1256
                            MYHDL147_adv((skip + 16));
1257
                            deflate0_0_cur_i <= 0;
1258
                            deflate0_0_offset <= 7;
1259
                        end
1260
                        default: begin
1261
                            deflate0_0_state <= 5'b00000;
1262
                            $write("Bad method");
1263
                            $write("\n");
1264
                            $finish;
1265
                        end
1266
                    endcase
1267
                end
1268
            end
1269
            5'b10110: begin
1270
                no_adv = 0;
1271
                if ((!deflate0_0_filled)) begin
1272
                    no_adv = 1;
1273
                    deflate0_0_filled <= 1'b1;
1274
                end
1275
                else if ((deflate0_0_nb < 4)) begin
1276
                    no_adv = 1;
1277
                    // pass
1278
                end
1279
                else if ((deflate0_0_cur_cstatic == 0)) begin
1280
                    deflate0_0_flush <= 1'b0;
1281
                    deflate0_0_ob1 <= 0;
1282
                    deflate0_0_adler1 <= 1;
1283
                    deflate0_0_adler2 <= 0;
1284
                    deflate0_0_ladler1 <= 0;
1285
                    deflate0_0_oaddr <= 0;
1286
                    deflate0_0_obyte <= 120;
1287
                end
1288
                else if ((deflate0_0_cur_cstatic == 1)) begin
1289
                    deflate0_0_oaddr <= 1;
1290
                    deflate0_0_obyte <= 156;
1291
                    deflate0_0_do <= 2;
1292
                end
1293
                else if ((deflate0_0_cur_cstatic == 2)) begin
1294
                    deflate0_0_oaddr <= deflate0_0_do;
1295
                    deflate0_0_obyte <= MYHDL148_put(3, 3);
1296
                    MYHDL149_put_adv(3, 3);
1297
                end
1298
                else if (deflate0_0_flush) begin
1299
                    $write("flush");
1300
                    $write(" ");
1301
                    $write("%h", deflate0_0_do);
1302
                    $write(" ");
1303
                    $write("%h", deflate0_0_ob1);
1304
                    $write("\n");
1305
                    no_adv = 1;
1306
                    deflate0_0_oaddr <= deflate0_0_do;
1307
                    deflate0_0_obyte <= deflate0_0_ob1;
1308
                    MYHDL150_do_flush;
1309
                end
1310
                else if ((($signed({1'b0, deflate0_0_cur_cstatic}) - 3) > deflate0_0_isize)) begin
1311
                    if ((($signed({1'b0, deflate0_0_cur_cstatic}) - 3) == (deflate0_0_isize + 1))) begin
1312
                        $write("Put EOF");
1313
                        $write(" ");
1314
                        $write("%h", deflate0_0_do);
1315
                        $write("\n");
1316
                        cs_i = 256;
1317
                        outlen = deflate0_0_codeLength[cs_i];
1318
                        outbits = deflate0_0_code_bits[cs_i];
1319
                        $write("EOF BITS:");
1320
                        $write(" ");
1321
                        $write("%0d", cs_i);
1322
                        $write(" ");
1323
                        $write("%h", outlen);
1324
                        $write(" ");
1325
                        $write("%h", outbits);
1326
                        $write("\n");
1327
                        deflate0_0_oaddr <= deflate0_0_do;
1328
                        deflate0_0_obyte <= MYHDL151_put(outbits, outlen);
1329
                        MYHDL152_put_adv(outbits, outlen);
1330
                    end
1331
                    else if ((($signed({1'b0, deflate0_0_cur_cstatic}) - 3) == (deflate0_0_isize + 2))) begin
1332
                        $write("calc end adler");
1333
                        $write("\n");
1334
                        deflate0_0_adler2 <= ((deflate0_0_adler2 + deflate0_0_ladler1) % 65521);
1335
                        if ((deflate0_0_doo != 0)) begin
1336
                            deflate0_0_oaddr <= deflate0_0_do;
1337
                            deflate0_0_obyte <= deflate0_0_ob1;
1338
                            deflate0_0_do <= (deflate0_0_do + 1);
1339
                        end
1340
                    end
1341
                    else if ((($signed({1'b0, deflate0_0_cur_cstatic}) - 3) == (deflate0_0_isize + 3))) begin
1342
                        $write("c1");
1343
                        $write("\n");
1344
                        deflate0_0_oaddr <= deflate0_0_do;
1345
                        deflate0_0_obyte <= (deflate0_0_adler2 >>> 8);
1346
                        deflate0_0_do <= (deflate0_0_do + 1);
1347
                    end
1348
                    else if ((($signed({1'b0, deflate0_0_cur_cstatic}) - 3) == (deflate0_0_isize + 4))) begin
1349
                        $write("c2");
1350
                        $write("\n");
1351
                        deflate0_0_oaddr <= deflate0_0_do;
1352
                        deflate0_0_obyte <= (deflate0_0_adler2 & 255);
1353
                        deflate0_0_do <= (deflate0_0_do + 1);
1354
                    end
1355
                    else if ((($signed({1'b0, deflate0_0_cur_cstatic}) - 3) == (deflate0_0_isize + 5))) begin
1356
                        $write("c3");
1357
                        $write("\n");
1358
                        deflate0_0_oaddr <= deflate0_0_do;
1359
                        deflate0_0_obyte <= (deflate0_0_adler1 >>> 8);
1360
                        deflate0_0_do <= (deflate0_0_do + 1);
1361
                    end
1362
                    else if ((($signed({1'b0, deflate0_0_cur_cstatic}) - 3) == (deflate0_0_isize + 6))) begin
1363
                        $write("c4");
1364
                        $write("\n");
1365
                        deflate0_0_oaddr <= deflate0_0_do;
1366
                        deflate0_0_obyte <= (deflate0_0_adler1 & 255);
1367
                    end
1368
                    else if ((($signed({1'b0, deflate0_0_cur_cstatic}) - 3) == (deflate0_0_isize + 7))) begin
1369
                        $write("EOF finish");
1370
                        $write(" ");
1371
                        $write("%h", deflate0_0_do);
1372
                        $write("\n");
1373
                        o_done <= 1'b1;
1374
                        o_oprogress <= (deflate0_0_do + 1);
1375
                        deflate0_0_state <= 5'b00000;
1376
                    end
1377
                    else begin
1378
                        $write("%h", deflate0_0_cur_cstatic);
1379
                        $write(" ");
1380
                        $write("%h", deflate0_0_isize);
1381
                        $write("\n");
1382
                        $finish;
1383
                    end
1384
                end
1385
                else begin
1386
                    bdata = deflate0_0_iram[deflate0_0_di];
1387
                    adler1_next = ((deflate0_0_adler1 + bdata) % 65521);
1388
                    deflate0_0_adler1 <= adler1_next;
1389
                    deflate0_0_adler2 <= ((deflate0_0_adler2 + deflate0_0_ladler1) % 65521);
1390
                    deflate0_0_ladler1 <= adler1_next;
1391
                    deflate0_0_state <= 5'b10111;
1392
                    deflate0_0_cur_search <= (deflate0_0_di - 1);
1393
                end
1394
                if ((!no_adv)) begin
1395
                    deflate0_0_cur_cstatic <= (deflate0_0_cur_cstatic + 1);
1396
                end
1397
            end
1398
            5'b11000: begin
1399
                if (deflate0_0_flush) begin
1400
                    MYHDL153_do_flush;
1401
                end
1402
                else begin
1403
                    case ((deflate0_0_cur_i + 1))
1404
                        0: nextdist = 1;
1405
                        1: nextdist = 2;
1406
                        2: nextdist = 3;
1407
                        3: nextdist = 4;
1408
                        4: nextdist = 5;
1409
                        5: nextdist = 7;
1410
                        6: nextdist = 9;
1411
                        7: nextdist = 13;
1412
                        8: nextdist = 17;
1413
                        9: nextdist = 25;
1414
                        10: nextdist = 33;
1415
                        11: nextdist = 49;
1416
                        12: nextdist = 65;
1417
                        13: nextdist = 97;
1418
                        14: nextdist = 129;
1419
                        15: nextdist = 193;
1420
                        16: nextdist = 257;
1421
                        17: nextdist = 385;
1422
                        18: nextdist = 513;
1423
                        19: nextdist = 769;
1424
                        20: nextdist = 1025;
1425
                        21: nextdist = 1537;
1426
                        22: nextdist = 2049;
1427
                        23: nextdist = 3073;
1428
                        24: nextdist = 4097;
1429
                        25: nextdist = 6145;
1430
                        26: nextdist = 8193;
1431
                        27: nextdist = 12289;
1432
                        28: nextdist = 16385;
1433
                        default: nextdist = 24577;
1434
                    endcase
1435
                    if ((nextdist > deflate0_0_cur_dist)) begin
1436
                        case (deflate0_0_cur_i)
1437
                            0: copydist = 1;
1438
                            1: copydist = 2;
1439
                            2: copydist = 3;
1440
                            3: copydist = 4;
1441
                            4: copydist = 5;
1442
                            5: copydist = 7;
1443
                            6: copydist = 9;
1444
                            7: copydist = 13;
1445
                            8: copydist = 17;
1446
                            9: copydist = 25;
1447
                            10: copydist = 33;
1448
                            11: copydist = 49;
1449
                            12: copydist = 65;
1450
                            13: copydist = 97;
1451
                            14: copydist = 129;
1452
                            15: copydist = 193;
1453
                            16: copydist = 257;
1454
                            17: copydist = 385;
1455
                            18: copydist = 513;
1456
                            19: copydist = 769;
1457
                            20: copydist = 1025;
1458
                            21: copydist = 1537;
1459
                            22: copydist = 2049;
1460
                            23: copydist = 3073;
1461
                            24: copydist = 4097;
1462
                            25: copydist = 6145;
1463
                            26: copydist = 8193;
1464
                            27: copydist = 12289;
1465
                            28: copydist = 16385;
1466
                            default: copydist = 24577;
1467
                        endcase
1468
                        extra_dist = (deflate0_0_cur_dist - copydist);
1469
                        case ((deflate0_0_cur_i / 2))
1470
                            0: extra_bits = 0;
1471
                            1: extra_bits = 0;
1472
                            2: extra_bits = 1;
1473
                            3: extra_bits = 2;
1474
                            4: extra_bits = 3;
1475
                            5: extra_bits = 4;
1476
                            6: extra_bits = 5;
1477
                            7: extra_bits = 6;
1478
                            8: extra_bits = 7;
1479
                            9: extra_bits = 8;
1480
                            10: extra_bits = 9;
1481
                            11: extra_bits = 10;
1482
                            12: extra_bits = 11;
1483
                            13: extra_bits = 12;
1484
                            default: extra_bits = 13;
1485
                        endcase
1486
                        if ((extra_dist > ((1 << extra_bits) - 1))) begin
1487
                            $finish;
1488
                        end
1489
                        outcode = (MYHDL154_rev_bits(deflate0_0_cur_i, 5) | (extra_dist << 5));
1490
                        deflate0_0_oaddr <= deflate0_0_do;
1491
                        deflate0_0_obyte <= MYHDL155_put(outcode, (5 + extra_bits));
1492
                        MYHDL156_put_adv(outcode, (5 + extra_bits));
1493
                        deflate0_0_cur_i <= (($signed({1'b0, deflate0_0_di}) - $signed({1'b0, deflate0_0_length})) + 1);
1494
                        deflate0_0_state <= 5'b11001;
1495
                    end
1496
                    else begin
1497
                        deflate0_0_cur_i <= (deflate0_0_cur_i + 1);
1498
                    end
1499
                end
1500
            end
1501
            5'b11001: begin
1502
                if ((deflate0_0_cur_i < deflate0_0_di)) begin
1503
                    bdata = deflate0_0_iram[(deflate0_0_cur_i & 127)];
1504
                    adler1_next = ((deflate0_0_adler1 + bdata) % 65521);
1505
                    deflate0_0_adler1 <= adler1_next;
1506
                    deflate0_0_adler2 <= ((deflate0_0_adler2 + deflate0_0_ladler1) % 65521);
1507
                    deflate0_0_ladler1 <= adler1_next;
1508
                    deflate0_0_cur_i <= (deflate0_0_cur_i + 1);
1509
                end
1510
                else begin
1511
                    deflate0_0_state <= 5'b10110;
1512
                end
1513
            end
1514
            5'b10111: begin
1515
                if ((!deflate0_0_filled)) begin
1516
                    deflate0_0_filled <= 1'b1;
1517
                end
1518
                else if ((deflate0_0_nb < 4)) begin
1519
                    // pass
1520
                end
1521
                else begin
1522
                    if (((deflate0_0_cur_search >= 0) && (deflate0_0_cur_search >= ($signed({1'b0, deflate0_0_di}) - 32)) && ($signed({1'b0, deflate0_0_di}) < ($signed({1'b0, deflate0_0_isize}) - 3)))) begin
1523
                        if (((deflate0_0_iram[(deflate0_0_cur_search & 127)] == deflate0_0_b1) && (deflate0_0_iram[((deflate0_0_cur_search + 1) & 127)] == deflate0_0_b2) && (deflate0_0_iram[((deflate0_0_cur_search + 2) & 127)] == deflate0_0_b3))) begin
1524
                            lencode = 257;
1525
                            match = 3;
1526
                            if ((($signed({1'b0, deflate0_0_di}) < ($signed({1'b0, deflate0_0_isize}) - 4)) && (deflate0_0_iram[((deflate0_0_cur_search + 3) & 127)] == deflate0_0_b4))) begin
1527
                                lencode = 258;
1528
                                match = 4;
1529
                                if ((($signed({1'b0, deflate0_0_di}) < ($signed({1'b0, deflate0_0_isize}) - 5)) && (deflate0_0_iram[((deflate0_0_cur_search + 4) & 127)] == deflate0_0_iram[((deflate0_0_di + 4) & 127)]))) begin
1530
                                    lencode = 259;
1531
                                    match = 5;
1532
                                end
1533
                            end
1534
                            // if di < isize - 6 and                                             iram[cur_search+5 & IBS] == iram[di + 5 & IBS]:
1535
                            //     lencode = 260
1536
                            //     match = 6
1537
                            //     if di < isize - 7 and                                                 iram[cur_search+6 & IBS] == iram[di + 6 & IBS]:
1538
                            //         lencode = 261
1539
                            //         match = 7
1540
                            //         if di < isize - 8 and                                                     iram[cur_search+7 & IBS] == iram[di + 7 & IBS]:
1541
                            //             lencode = 262
1542
                            //             match = 8
1543
                            //             if di < isize - 9 and                                                         iram[cur_search+8 & IBS] == iram[di + 8 & IBS]:
1544
                            //                 lencode = 263
1545
                            //                 match = 9
1546
                            //                 if di < isize - 10 and                                                             iram[cur_search+9 & IBS] == iram[di + 9 & IBS]:
1547
                            //                     lencode = 264
1548
                            //                     match = 10
1549
                            $write("found:");
1550
                            $write(" ");
1551
                            $write("%h", deflate0_0_cur_search);
1552
                            $write(" ");
1553
                            $write("%h", deflate0_0_di);
1554
                            $write(" ");
1555
                            $write("%h", deflate0_0_isize);
1556
                            $write(" ");
1557
                            $write("%0d", match);
1558
                            $write("\n");
1559
                            outlen = deflate0_0_codeLength[lencode];
1560
                            outbits = deflate0_0_code_bits[lencode];
1561
                            deflate0_0_oaddr <= deflate0_0_do;
1562
                            deflate0_0_obyte <= MYHDL157_put(outbits, outlen);
1563
                            MYHDL158_put_adv(outbits, outlen);
1564
                            distance = ($signed({1'b0, deflate0_0_di}) - deflate0_0_cur_search);
1565
                            deflate0_0_cur_dist <= distance;
1566
                            deflate0_0_cur_i <= 0;
1567
                            deflate0_0_di <= (deflate0_0_di + match);
1568
                            deflate0_0_cur_cstatic <= ((deflate0_0_cur_cstatic + match) - 1);
1569
                            deflate0_0_length <= match;
1570
                            deflate0_0_state <= 5'b11000;
1571
                        end
1572
                        else begin
1573
                            deflate0_0_cur_search <= (deflate0_0_cur_search - 1);
1574
                        end
1575
                    end
1576
                    else begin
1577
                        bdata = deflate0_0_iram[deflate0_0_di];
1578
                        deflate0_0_di <= (deflate0_0_di + 1);
1579
                        outlen = deflate0_0_codeLength[bdata];
1580
                        outbits = deflate0_0_code_bits[bdata];
1581
                        deflate0_0_oaddr <= deflate0_0_do;
1582
                        deflate0_0_obyte <= MYHDL159_put(outbits, outlen);
1583
                        MYHDL160_put_adv(outbits, outlen);
1584
                        deflate0_0_state <= 5'b10110;
1585
                    end
1586
                end
1587
            end
1588
            5'b01110: begin
1589
                for (stat_i=0; stat_i<144; stat_i=stat_i+1) begin
1590
                    deflate0_0_codeLength[stat_i] <= 8;
1591
                end
1592
                for (stat_i=144; stat_i<256; stat_i=stat_i+1) begin
1593
                    deflate0_0_codeLength[stat_i] <= 9;
1594
                end
1595
                for (stat_i=256; stat_i<280; stat_i=stat_i+1) begin
1596
                    deflate0_0_codeLength[stat_i] <= 7;
1597
                end
1598
                for (stat_i=280; stat_i<288; stat_i=stat_i+1) begin
1599
                    deflate0_0_codeLength[stat_i] <= 8;
1600
                end
1601
                deflate0_0_numCodeLength <= 288;
1602
                deflate0_0_cur_HF1 <= 0;
1603
                deflate0_0_state <= 5'b00111;
1604
                // if cur_static < 288:
1605
                //     if cur_static < 144:
1606
                //         codeLength[cur_static].next = 8
1607
                //     elif cur_static < 256:
1608
                //         codeLength[cur_static].next = 9
1609
                //     elif cur_static < 280:
1610
                //         codeLength[cur_static].next = 7
1611
                //     else:
1612
                //         codeLength[cur_static].next = 8
1613
                //     cur_static.next = cur_static + 1
1614
                // else:
1615
                //     numCodeLength.next = 288
1616
                //     cur_HF1.next = 0
1617
                //     state.next = d_state.HF1
1618
            end
1619
            5'b00010: begin
1620
                if ((!deflate0_0_filled)) begin
1621
                    deflate0_0_filled <= 1'b1;
1622
                end
1623
                else if ((deflate0_0_nb < 4)) begin
1624
                    // pass
1625
                end
1626
                else if ((deflate0_0_numLiterals == 0)) begin
1627
                    deflate0_0_numLiterals <= (257 + MYHDL169_get4(0, 5));
1628
                    $write("NL:");
1629
                    $write(" ");
1630
                    $write("%0d", (257 + MYHDL170_get4(0, 5)));
1631
                    $write("\n");
1632
                    deflate0_0_numDistance <= (1 + MYHDL171_get4(5, 5));
1633
                    $write("ND:");
1634
                    $write(" ");
1635
                    $write("%0d", (1 + MYHDL172_get4(5, 5)));
1636
                    $write("\n");
1637
                    deflate0_0_b_numCodeLength <= (4 + MYHDL173_get4(10, 4));
1638
                    $write("NCL:");
1639
                    $write(" ");
1640
                    $write("%0d", (4 + MYHDL174_get4(10, 4)));
1641
                    $write("\n");
1642
                    deflate0_0_numCodeLength <= 0;
1643
                    MYHDL175_adv(14);
1644
                end
1645
                else begin
1646
                    if ((deflate0_0_numCodeLength < 19)) begin
1647
                        case (deflate0_0_numCodeLength)
1648
                            0: clo_i = 16;
1649
                            1: clo_i = 17;
1650
                            2: clo_i = 18;
1651
                            3: clo_i = 0;
1652
                            4: clo_i = 8;
1653
                            5: clo_i = 7;
1654
                            6: clo_i = 9;
1655
                            7: clo_i = 6;
1656
                            8: clo_i = 10;
1657
                            9: clo_i = 5;
1658
                            10: clo_i = 11;
1659
                            11: clo_i = 4;
1660
                            12: clo_i = 12;
1661
                            13: clo_i = 3;
1662
                            14: clo_i = 13;
1663
                            15: clo_i = 2;
1664
                            16: clo_i = 14;
1665
                            17: clo_i = 1;
1666
                            default: clo_i = 15;
1667
                        endcase
1668
                        if ((deflate0_0_numCodeLength < deflate0_0_b_numCodeLength)) begin
1669
                            deflate0_0_codeLength[clo_i] <= MYHDL176_get4(0, 3);
1670
                            MYHDL177_adv(3);
1671
                        end
1672
                        else begin
1673
                            deflate0_0_codeLength[clo_i] <= 0;
1674
                        end
1675
                        deflate0_0_numCodeLength <= (deflate0_0_numCodeLength + 1);
1676
                    end
1677
                    else begin
1678
                        deflate0_0_numCodeLength <= 19;
1679
                        deflate0_0_cur_HF1 <= 0;
1680
                        deflate0_0_state <= 5'b00111;
1681
                    end
1682
                end
1683
            end
1684
            5'b00011: begin
1685
                if ((!deflate0_0_filled)) begin
1686
                    deflate0_0_filled <= 1'b1;
1687
                end
1688
                else if ((deflate0_0_nb < 4)) begin
1689
                    // pass
1690
                end
1691
                else if ((deflate0_0_numCodeLength < (deflate0_0_numLiterals + deflate0_0_numDistance))) begin
1692
                    n_adv = 0;
1693
                    if ((deflate0_0_code < 16)) begin
1694
                        deflate0_0_howOften <= 1;
1695
                        deflate0_0_lastToken <= deflate0_0_code;
1696
                    end
1697
                    else if ((deflate0_0_code == 16)) begin
1698
                        deflate0_0_howOften <= (3 + MYHDL178_get4(0, 2));
1699
                        n_adv = 2;
1700
                    end
1701
                    else if ((deflate0_0_code == 17)) begin
1702
                        deflate0_0_howOften <= (3 + MYHDL179_get4(0, 3));
1703
                        deflate0_0_lastToken <= 0;
1704
                        n_adv = 3;
1705
                    end
1706
                    else if ((deflate0_0_code == 18)) begin
1707
                        deflate0_0_howOften <= (11 + MYHDL180_get4(0, 7));
1708
                        deflate0_0_lastToken <= 0;
1709
                        n_adv = 7;
1710
                    end
1711
                    else begin
1712
                        $finish;
1713
                    end
1714
                    if ((n_adv != 0)) begin
1715
                        MYHDL181_adv(n_adv);
1716
                    end
1717
                    deflate0_0_state <= 5'b00100;
1718
                end
1719
                else begin
1720
                    $write("FILL UP");
1721
                    $write("\n");
1722
                    for (dbl_i=0; dbl_i<32; dbl_i=dbl_i+1) begin
1723
                        dbl = 0;
1724
                        if (((dbl_i + $signed({1'b0, deflate0_0_numLiterals})) < deflate0_0_numCodeLength)) begin
1725
                            dbl = deflate0_0_codeLength[(dbl_i + $signed({1'b0, deflate0_0_numLiterals}))];
1726
                        end
1727
                        deflate0_0_distanceLength[dbl_i] <= dbl;
1728
                    end
1729
                    deflate0_0_cur_i <= deflate0_0_numLiterals;
1730
                    deflate0_0_state <= 5'b00110;
1731
                end
1732
            end
1733
            default: begin
1734
                if ((deflate0_0_state == 5'b00110)) begin
1735
                    if ((deflate0_0_cur_i < 288)) begin
1736
                        deflate0_0_codeLength[deflate0_0_cur_i] <= 0;
1737
                        deflate0_0_cur_i <= (deflate0_0_cur_i + 1);
1738
                    end
1739
                    else begin
1740
                        deflate0_0_numCodeLength <= 288;
1741
                        deflate0_0_method <= 3;
1742
                        deflate0_0_cur_HF1 <= 0;
1743
                        deflate0_0_state <= 5'b00111;
1744
                    end
1745
                end
1746
                else begin
1747
                    case (deflate0_0_state)
1748
                        5'b00101: begin
1749
                            $write("DISTTREE");
1750
                            $write("\n");
1751
                            for (dist_i=0; dist_i<32; dist_i=dist_i+1) begin
1752
                                deflate0_0_codeLength[dist_i] <= deflate0_0_distanceLength[dist_i];
1753
                            end
1754
                            deflate0_0_numCodeLength <= 32;
1755
                            deflate0_0_method <= 4;
1756
                            deflate0_0_cur_HF1 <= 0;
1757
                            deflate0_0_state <= 5'b00111;
1758
                        end
1759
                        5'b00100: begin
1760
                            if ((deflate0_0_howOften != 0)) begin
1761
                                deflate0_0_codeLength[deflate0_0_numCodeLength] <= deflate0_0_lastToken;
1762
                                deflate0_0_howOften <= (deflate0_0_howOften - 1);
1763
                                deflate0_0_numCodeLength <= (deflate0_0_numCodeLength + 1);
1764
                            end
1765
                            else if ((deflate0_0_numCodeLength < (deflate0_0_numLiterals + deflate0_0_numDistance))) begin
1766
                                deflate0_0_cur_next <= 0;
1767
                                deflate0_0_state <= 5'b10011;
1768
                            end
1769
                            else begin
1770
                                deflate0_0_state <= 5'b00011;
1771
                            end
1772
                        end
1773
                        5'b00111: begin
1774
                            if ((deflate0_0_cur_HF1 < 16)) begin
1775
                                deflate0_0_bitLengthCount[deflate0_0_cur_HF1] <= 0;
1776
                            end
1777
                            if ((deflate0_0_cur_HF1 < 128)) begin
1778
                                deflate0_0_d_leaves[deflate0_0_cur_HF1] <= 0;
1779
                            end
1780
                            if (((deflate0_0_method != 4) && (deflate0_0_cur_HF1 < 512))) begin
1781
                                deflate0_0_lwaddr <= deflate0_0_cur_HF1;
1782
                                deflate0_0_wleaf <= 0;
1783
                            end
1784
                            limit = 512;
1785
                            if ((deflate0_0_method == 4)) begin
1786
                                limit = 128;
1787
                            end
1788
                            if ((deflate0_0_cur_HF1 < limit)) begin
1789
                                deflate0_0_cur_HF1 <= (deflate0_0_cur_HF1 + 1);
1790
                            end
1791
                            else begin
1792
                                $write("DID HF1 INIT");
1793
                                $write("\n");
1794
                                deflate0_0_cur_i <= 0;
1795
                                deflate0_0_state <= 5'b01000;
1796
                            end
1797
                        end
1798
                        5'b01000: begin
1799
                            if ((deflate0_0_cur_i < deflate0_0_numCodeLength)) begin
1800
                                j = deflate0_0_codeLength[deflate0_0_cur_i];
1801
                                deflate0_0_bitLengthCount[j] <= (deflate0_0_bitLengthCount[j] + 1);
1802
                                deflate0_0_cur_i <= (deflate0_0_cur_i + 1);
1803
                            end
1804
                            else begin
1805
                                deflate0_0_bitLengthCount[0] <= 0;
1806
                                deflate0_0_state <= 5'b01001;
1807
                                deflate0_0_cur_i <= 1;
1808
                                if ((deflate0_0_method == 4)) begin
1809
                                    deflate0_0_d_maxBits <= 0;
1810
                                end
1811
                                else begin
1812
                                    deflate0_0_maxBits <= 0;
1813
                                end
1814
                                deflate0_0_minBits <= 15;
1815
                            end
1816
                        end
1817
                        5'b01001: begin
1818
                            if ((deflate0_0_cur_i <= 15)) begin
1819
                                if ((deflate0_0_bitLengthCount[deflate0_0_cur_i] != 0)) begin
1820
                                    if ((deflate0_0_cur_i < deflate0_0_minBits)) begin
1821
                                        deflate0_0_minBits <= deflate0_0_cur_i;
1822
                                    end
1823
                                    if ((deflate0_0_method == 4)) begin
1824
                                        if ((deflate0_0_cur_i > deflate0_0_d_maxBits)) begin
1825
                                            deflate0_0_d_maxBits <= deflate0_0_cur_i;
1826
                                        end
1827
                                    end
1828
                                    else begin
1829
                                        if ((deflate0_0_cur_i > deflate0_0_maxBits)) begin
1830
                                            deflate0_0_maxBits <= deflate0_0_cur_i;
1831
                                        end
1832
                                    end
1833
                                end
1834
                                deflate0_0_cur_i <= (deflate0_0_cur_i + 1);
1835
                            end
1836
                            else begin
1837
                                $write("%h", deflate0_0_minBits);
1838
                                $write(" ");
1839
                                $write("%h", deflate0_0_maxBits);
1840
                                $write("\n");
1841
                                t = 10;
1842
                                if ((deflate0_0_method == 4)) begin
1843
                                    if ((t > deflate0_0_d_maxBits)) begin
1844
                                        t = deflate0_0_d_maxBits;
1845
                                    end
1846
                                    deflate0_0_d_instantMaxBit <= t;
1847
                                    deflate0_0_d_instantMask <= ((1 << t) - 1);
1848
                                end
1849
                                else begin
1850
                                    if ((t > deflate0_0_maxBits)) begin
1851
                                        t = deflate0_0_maxBits;
1852
                                    end
1853
                                    deflate0_0_instantMaxBit <= t;
1854
                                    deflate0_0_instantMask <= ((1 << t) - 1);
1855
                                end
1856
                                $write("%0d", ((1 << t) - 1));
1857
                                $write("\n");
1858
                                deflate0_0_state <= 5'b01010;
1859
                                deflate0_0_cur_i <= deflate0_0_minBits;
1860
                                deflate0_0_code <= 0;
1861
                                for (hf2_i=0; hf2_i<15; hf2_i=hf2_i+1) begin
1862
                                    deflate0_0_nextCode[hf2_i] <= 0;
1863
                                end
1864
                                $write("to HF3");
1865
                                $write("\n");
1866
                            end
1867
                        end
1868
                        5'b01010: begin
1869
                            amb = deflate0_0_maxBits;
1870
                            if ((deflate0_0_method == 4)) begin
1871
                                amb = deflate0_0_d_maxBits;
1872
                            end
1873
                            if ((deflate0_0_cur_i <= amb)) begin
1874
                                ncode = ((deflate0_0_code + deflate0_0_bitLengthCount[($signed({1'b0, deflate0_0_cur_i}) - 1)]) << 1);
1875
                                deflate0_0_code <= ncode;
1876
                                deflate0_0_nextCode[deflate0_0_cur_i] <= ncode;
1877
                                deflate0_0_cur_i <= (deflate0_0_cur_i + 1);
1878
                            end
1879
                            else begin
1880
                                deflate0_0_state <= 5'b01011;
1881
                                deflate0_0_cur_i <= 0;
1882
                                deflate0_0_spread_i <= 0;
1883
                                $write("to HF4");
1884
                                $write("\n");
1885
                            end
1886
                        end
1887
                        5'b01100: begin
1888
                            canonical = deflate0_0_nextCode[deflate0_0_bits];
1889
                            deflate0_0_nextCode[deflate0_0_bits] <= (deflate0_0_nextCode[deflate0_0_bits] + 1);
1890
                            if ((deflate0_0_bits > 15)) begin
1891
                                $finish;
1892
                            end
1893
                            deflate0_0_reverse <= MYHDL188_rev_bits(canonical, deflate0_0_bits);
1894
                            deflate0_0_leaf <= MYHDL189_makeLeaf(deflate0_0_spread_i, deflate0_0_bits);
1895
                            deflate0_0_state <= 5'b01101;
1896
                        end
1897
                        5'b01101: begin
1898
                            if ((deflate0_0_method == 4)) begin
1899
                                deflate0_0_d_leaves[deflate0_0_reverse] <= deflate0_0_leaf;
1900
                                if ((deflate0_0_bits <= deflate0_0_d_instantMaxBit)) begin
1901
                                    if (((deflate0_0_reverse + (1 << deflate0_0_bits)) <= deflate0_0_d_instantMask)) begin
1902
                                        deflate0_0_step <= (1 << deflate0_0_bits);
1903
                                        deflate0_0_spread <= (deflate0_0_reverse + (1 << deflate0_0_bits));
1904
                                        deflate0_0_state <= 5'b10010;
1905
                                    end
1906
                                    else begin
1907
                                        deflate0_0_spread_i <= (deflate0_0_spread_i + 1);
1908
                                        deflate0_0_state <= 5'b01011;
1909
                                    end
1910
                                end
1911
                                else begin
1912
                                    deflate0_0_state <= 5'b01011;
1913
                                    deflate0_0_spread_i <= (deflate0_0_spread_i + 1);
1914
                                end
1915
                            end
1916
                            else begin
1917
                                deflate0_0_wleaf <= deflate0_0_leaf;
1918
                                deflate0_0_lwaddr <= deflate0_0_reverse;
1919
                                deflate0_0_code_bits[deflate0_0_spread_i] <= deflate0_0_reverse;
1920
                                if ((deflate0_0_bits <= deflate0_0_instantMaxBit)) begin
1921
                                    if (((deflate0_0_reverse + (1 << deflate0_0_bits)) <= deflate0_0_instantMask)) begin
1922
                                        deflate0_0_step <= (1 << deflate0_0_bits);
1923
                                        deflate0_0_spread <= (deflate0_0_reverse + (1 << deflate0_0_bits));
1924
                                        deflate0_0_state <= 5'b10010;
1925
                                    end
1926
                                    else begin
1927
                                        deflate0_0_spread_i <= (deflate0_0_spread_i + 1);
1928
                                        deflate0_0_state <= 5'b01011;
1929
                                    end
1930
                                end
1931
                                else begin
1932
                                    deflate0_0_spread_i <= (deflate0_0_spread_i + 1);
1933
                                    deflate0_0_state <= 5'b01011;
1934
                                end
1935
                            end
1936
                        end
1937
                        5'b01011: begin
1938
                            if ((deflate0_0_spread_i < deflate0_0_numCodeLength)) begin
1939
                                bits_next = deflate0_0_codeLength[deflate0_0_spread_i];
1940
                                if ((bits_next != 0)) begin
1941
                                    deflate0_0_bits <= bits_next;
1942
                                    deflate0_0_state <= 5'b01100;
1943
                                end
1944
                                else begin
1945
                                    deflate0_0_spread_i <= (deflate0_0_spread_i + 1);
1946
                                end
1947
                            end
1948
                            else begin
1949
                                if (deflate0_0_do_compress) begin
1950
                                    deflate0_0_state <= 5'b10110;
1951
                                    deflate0_0_cur_cstatic <= 0;
1952
                                end
1953
                                else if ((deflate0_0_method == 3)) begin
1954
                                    deflate0_0_state <= 5'b00101;
1955
                                end
1956
                                else if ((deflate0_0_method == 4)) begin
1957
                                    $write("DEFLATE m2!");
1958
                                    $write("\n");
1959
                                    deflate0_0_state <= 5'b10011;
1960
                                end
1961
                                else if ((deflate0_0_method == 2)) begin
1962
                                    deflate0_0_numCodeLength <= 0;
1963
                                    deflate0_0_state <= 5'b10011;
1964
                                end
1965
                                else begin
1966
                                    deflate0_0_state <= 5'b10011;
1967
                                end
1968
                                deflate0_0_cur_next <= 0;
1969
                                deflate0_0_cur_i <= 0;
1970
                            end
1971
                        end
1972
                        5'b10010: begin
1973
                            if ((deflate0_0_method == 4)) begin
1974
                                deflate0_0_d_leaves[deflate0_0_spread] <= MYHDL190_makeLeaf(deflate0_0_spread_i, deflate0_0_codeLength[deflate0_0_spread_i]);
1975
                            end
1976
                            else begin
1977
                                deflate0_0_lwaddr <= deflate0_0_spread;
1978
                                deflate0_0_wleaf <= MYHDL191_makeLeaf(deflate0_0_spread_i, deflate0_0_codeLength[deflate0_0_spread_i]);
1979
                            end
1980
                            aim = deflate0_0_instantMask;
1981
                            if ((deflate0_0_method == 4)) begin
1982
                                aim = deflate0_0_d_instantMask;
1983
                            end
1984
                            if (($signed({1'b0, deflate0_0_spread}) > ($signed({1'b0, aim}) - $signed({1'b0, deflate0_0_step})))) begin
1985
                                deflate0_0_spread_i <= (deflate0_0_spread_i + 1);
1986
                                deflate0_0_state <= 5'b01011;
1987
                            end
1988
                            else begin
1989
                                deflate0_0_spread <= (deflate0_0_spread + deflate0_0_step);
1990
                            end
1991
                        end
1992
                        5'b10011: begin
1993
                            if ((!deflate0_0_filled)) begin
1994
                                deflate0_0_filled <= 1'b1;
1995
                            end
1996
                            else if ((deflate0_0_nb < 4)) begin
1997
                                // pass
1998
                            end
1999
                            else if ((deflate0_0_cur_next == 0)) begin
2000
                                cto = MYHDL192_get4(0, deflate0_0_maxBits);
2001
                                deflate0_0_cur_next <= 1;
2002
                                mask = ((1 << deflate0_0_instantMaxBit) - 1);
2003
                                deflate0_0_leaf <= deflate0_0_leaves[(cto & mask)];
2004
                            end
2005
                            else begin
2006
                                if ((MYHDL193_get_bits(deflate0_0_leaf) < 1)) begin
2007
                                    $write("< 1 bits: ");
2008
                                    $write("\n");
2009
                                    $finish;
2010
                                end
2011
                                MYHDL195_adv(MYHDL194_get_bits(deflate0_0_leaf));
2012
                                if ((MYHDL196_get_code(deflate0_0_leaf) == 0)) begin
2013
                                    $write("leaf 0");
2014
                                    $write("\n");
2015
                                end
2016
                                deflate0_0_code <= MYHDL197_get_code(deflate0_0_leaf);
2017
                                if ((deflate0_0_method == 2)) begin
2018
                                    deflate0_0_state <= 5'b00011;
2019
                                end
2020
                                else begin
2021
                                    deflate0_0_state <= 5'b10100;
2022
                                end
2023
                            end
2024
                        end
2025
                        5'b01111: begin
2026
                            if ((!deflate0_0_filled)) begin
2027
                                deflate0_0_filled <= 1'b1;
2028
                            end
2029
                            else if ((deflate0_0_nb < 4)) begin
2030
                                // pass
2031
                            end
2032
                            else begin
2033
                                token = (deflate0_0_code - 257);
2034
                                case (token)
2035
                                    0: extraLength = 0;
2036
                                    1: extraLength = 0;
2037
                                    2: extraLength = 0;
2038
                                    3: extraLength = 0;
2039
                                    4: extraLength = 0;
2040
                                    5: extraLength = 0;
2041
                                    6: extraLength = 0;
2042
                                    7: extraLength = 0;
2043
                                    8: extraLength = 1;
2044
                                    9: extraLength = 1;
2045
                                    10: extraLength = 1;
2046
                                    11: extraLength = 1;
2047
                                    12: extraLength = 2;
2048
                                    13: extraLength = 2;
2049
                                    14: extraLength = 2;
2050
                                    15: extraLength = 2;
2051
                                    16: extraLength = 3;
2052
                                    17: extraLength = 3;
2053
                                    18: extraLength = 3;
2054
                                    19: extraLength = 3;
2055
                                    20: extraLength = 4;
2056
                                    21: extraLength = 4;
2057
                                    22: extraLength = 4;
2058
                                    23: extraLength = 4;
2059
                                    24: extraLength = 5;
2060
                                    25: extraLength = 5;
2061
                                    26: extraLength = 5;
2062
                                    27: extraLength = 5;
2063
                                    default: extraLength = 0;
2064
                                endcase
2065
                                cto = MYHDL198_get4(extraLength, deflate0_0_d_maxBits);
2066
                                mask = ((1 << deflate0_0_d_instantMaxBit) - 1);
2067
                                deflate0_0_leaf <= deflate0_0_d_leaves[(cto & mask)];
2068
                                deflate0_0_state <= 5'b10000;
2069
                            end
2070
                        end
2071
                        5'b10000: begin
2072
                            if ((MYHDL199_get_bits(deflate0_0_leaf) == 0)) begin
2073
                                $finish;
2074
                            end
2075
                            token = (deflate0_0_code - 257);
2076
                            case (token)
2077
                                0: tlength = 3;
2078
                                1: tlength = 4;
2079
                                2: tlength = 5;
2080
                                3: tlength = 6;
2081
                                4: tlength = 7;
2082
                                5: tlength = 8;
2083
                                6: tlength = 9;
2084
                                7: tlength = 10;
2085
                                8: tlength = 11;
2086
                                9: tlength = 13;
2087
                                10: tlength = 15;
2088
                                11: tlength = 17;
2089
                                12: tlength = 19;
2090
                                13: tlength = 23;
2091
                                14: tlength = 27;
2092
                                15: tlength = 31;
2093
                                16: tlength = 35;
2094
                                17: tlength = 43;
2095
                                18: tlength = 51;
2096
                                19: tlength = 59;
2097
                                20: tlength = 67;
2098
                                21: tlength = 83;
2099
                                22: tlength = 99;
2100
                                23: tlength = 115;
2101
                                24: tlength = 131;
2102
                                25: tlength = 163;
2103
                                26: tlength = 195;
2104
                                27: tlength = 227;
2105
                                default: tlength = 258;
2106
                            endcase
2107
                            case (token)
2108
                                0: extraLength = 0;
2109
                                1: extraLength = 0;
2110
                                2: extraLength = 0;
2111
                                3: extraLength = 0;
2112
                                4: extraLength = 0;
2113
                                5: extraLength = 0;
2114
                                6: extraLength = 0;
2115
                                7: extraLength = 0;
2116
                                8: extraLength = 1;
2117
                                9: extraLength = 1;
2118
                                10: extraLength = 1;
2119
                                11: extraLength = 1;
2120
                                12: extraLength = 2;
2121
                                13: extraLength = 2;
2122
                                14: extraLength = 2;
2123
                                15: extraLength = 2;
2124
                                16: extraLength = 3;
2125
                                17: extraLength = 3;
2126
                                18: extraLength = 3;
2127
                                19: extraLength = 3;
2128
                                20: extraLength = 4;
2129
                                21: extraLength = 4;
2130
                                22: extraLength = 4;
2131
                                23: extraLength = 4;
2132
                                24: extraLength = 5;
2133
                                25: extraLength = 5;
2134
                                26: extraLength = 5;
2135
                                27: extraLength = 5;
2136
                                default: extraLength = 0;
2137
                            endcase
2138
                            tlength = tlength + MYHDL200_get4(0, extraLength);
2139
                            distanceCode = MYHDL201_get_code(deflate0_0_leaf);
2140
                            case (distanceCode)
2141
                                0: distance = 1;
2142
                                1: distance = 2;
2143
                                2: distance = 3;
2144
                                3: distance = 4;
2145
                                4: distance = 5;
2146
                                5: distance = 7;
2147
                                6: distance = 9;
2148
                                7: distance = 13;
2149
                                8: distance = 17;
2150
                                9: distance = 25;
2151
                                10: distance = 33;
2152
                                11: distance = 49;
2153
                                12: distance = 65;
2154
                                13: distance = 97;
2155
                                14: distance = 129;
2156
                                15: distance = 193;
2157
                                16: distance = 257;
2158
                                17: distance = 385;
2159
                                18: distance = 513;
2160
                                19: distance = 769;
2161
                                20: distance = 1025;
2162
                                21: distance = 1537;
2163
                                22: distance = 2049;
2164
                                23: distance = 3073;
2165
                                24: distance = 4097;
2166
                                25: distance = 6145;
2167
                                26: distance = 8193;
2168
                                27: distance = 12289;
2169
                                28: distance = 16385;
2170
                                default: distance = 24577;
2171
                            endcase
2172
                            case ($signed(distanceCode >>> 1))
2173
                                0: moreBits = 0;
2174
                                1: moreBits = 0;
2175
                                2: moreBits = 1;
2176
                                3: moreBits = 2;
2177
                                4: moreBits = 3;
2178
                                5: moreBits = 4;
2179
                                6: moreBits = 5;
2180
                                7: moreBits = 6;
2181
                                8: moreBits = 7;
2182
                                9: moreBits = 8;
2183
                                10: moreBits = 9;
2184
                                11: moreBits = 10;
2185
                                12: moreBits = 11;
2186
                                13: moreBits = 12;
2187
                                default: moreBits = 13;
2188
                            endcase
2189
                            mored = MYHDL203_get4((extraLength + MYHDL202_get_bits(deflate0_0_leaf)), moreBits);
2190
                            distance = distance + mored;
2191
                            MYHDL205_adv(((moreBits + extraLength) + MYHDL204_get_bits(deflate0_0_leaf)));
2192
                            deflate0_0_offset <= ($signed({1'b0, deflate0_0_do}) - distance);
2193
                            deflate0_0_length <= tlength;
2194
                            deflate0_0_cur_i <= 0;
2195
                            deflate0_0_oraddr <= deflate0_0_offset;
2196
                            deflate0_0_state <= 5'b10101;
2197
                        end
2198
                        default: begin
2199
                            if ((deflate0_0_state == 5'b10100)) begin
2200
                                if ((!deflate0_0_filled)) begin
2201
                                    deflate0_0_filled <= 1'b1;
2202
                                end
2203
                                else if ((deflate0_0_nb < 4)) begin
2204
                                    // pass
2205
                                end
2206
                                else if (($signed({1'b0, deflate0_0_di}) > ($signed({1'b0, deflate0_0_isize}) - 3))) begin
2207
                                    deflate0_0_state <= 5'b00000;
2208
                                    o_done <= 1'b1;
2209
                                    $write("NO EOF ");
2210
                                    $write(" ");
2211
                                    $write("%h", deflate0_0_di);
2212
                                    $write("\n");
2213
                                    $finish;
2214
                                end
2215
                                else if ((deflate0_0_code == 256)) begin
2216
                                    $write("EOF:");
2217
                                    $write(" ");
2218
                                    $write("%h", deflate0_0_di);
2219
                                    $write(" ");
2220
                                    $write("%h", deflate0_0_do);
2221
                                    $write("\n");
2222
                                    if ((!deflate0_0_final)) begin
2223
                                        deflate0_0_state <= 5'b00001;
2224
                                    end
2225
                                    else begin
2226
                                        o_done <= 1'b1;
2227
                                        o_oprogress <= deflate0_0_do;
2228
                                        deflate0_0_state <= 5'b00000;
2229
                                    end
2230
                                end
2231
                                else begin
2232
                                    if ((deflate0_0_code < 256)) begin
2233
                                        deflate0_0_oaddr <= deflate0_0_do;
2234
                                        deflate0_0_obyte <= deflate0_0_code;
2235
                                        o_oprogress <= (deflate0_0_do + 1);
2236
                                        deflate0_0_do <= (deflate0_0_do + 1);
2237
                                        deflate0_0_cur_next <= 0;
2238
                                        deflate0_0_state <= 5'b10011;
2239
                                    end
2240
                                    else if ((deflate0_0_code == 300)) begin
2241
                                        $finish;
2242
                                    end
2243
                                    else begin
2244
                                        if (deflate0_0_static) begin
2245
                                            token = (deflate0_0_code - 257);
2246
                                            case (token)
2247
                                                0: tlength = 3;
2248
                                                1: tlength = 4;
2249
                                                2: tlength = 5;
2250
                                                3: tlength = 6;
2251
                                                4: tlength = 7;
2252
                                                5: tlength = 8;
2253
                                                6: tlength = 9;
2254
                                                7: tlength = 10;
2255
                                                8: tlength = 11;
2256
                                                9: tlength = 13;
2257
                                                10: tlength = 15;
2258
                                                11: tlength = 17;
2259
                                                12: tlength = 19;
2260
                                                13: tlength = 23;
2261
                                                14: tlength = 27;
2262
                                                15: tlength = 31;
2263
                                                16: tlength = 35;
2264
                                                17: tlength = 43;
2265
                                                18: tlength = 51;
2266
                                                19: tlength = 59;
2267
                                                20: tlength = 67;
2268
                                                21: tlength = 83;
2269
                                                22: tlength = 99;
2270
                                                23: tlength = 115;
2271
                                                24: tlength = 131;
2272
                                                25: tlength = 163;
2273
                                                26: tlength = 195;
2274
                                                27: tlength = 227;
2275
                                                default: tlength = 258;
2276
                                            endcase
2277
                                            case (token)
2278
                                                0: extraLength = 0;
2279
                                                1: extraLength = 0;
2280
                                                2: extraLength = 0;
2281
                                                3: extraLength = 0;
2282
                                                4: extraLength = 0;
2283
                                                5: extraLength = 0;
2284
                                                6: extraLength = 0;
2285
                                                7: extraLength = 0;
2286
                                                8: extraLength = 1;
2287
                                                9: extraLength = 1;
2288
                                                10: extraLength = 1;
2289
                                                11: extraLength = 1;
2290
                                                12: extraLength = 2;
2291
                                                13: extraLength = 2;
2292
                                                14: extraLength = 2;
2293
                                                15: extraLength = 2;
2294
                                                16: extraLength = 3;
2295
                                                17: extraLength = 3;
2296
                                                18: extraLength = 3;
2297
                                                19: extraLength = 3;
2298
                                                20: extraLength = 4;
2299
                                                21: extraLength = 4;
2300
                                                22: extraLength = 4;
2301
                                                23: extraLength = 4;
2302
                                                24: extraLength = 5;
2303
                                                25: extraLength = 5;
2304
                                                26: extraLength = 5;
2305
                                                27: extraLength = 5;
2306
                                                default: extraLength = 0;
2307
                                            endcase
2308
                                            tlength = tlength + MYHDL206_get4(0, extraLength);
2309
                                            t = MYHDL207_get4(extraLength, 5);
2310
                                            distanceCode = MYHDL208_rev_bits(t, 5);
2311
                                            case (distanceCode)
2312
                                                0: distance = 1;
2313
                                                1: distance = 2;
2314
                                                2: distance = 3;
2315
                                                3: distance = 4;
2316
                                                4: distance = 5;
2317
                                                5: distance = 7;
2318
                                                6: distance = 9;
2319
                                                7: distance = 13;
2320
                                                8: distance = 17;
2321
                                                9: distance = 25;
2322
                                                10: distance = 33;
2323
                                                11: distance = 49;
2324
                                                12: distance = 65;
2325
                                                13: distance = 97;
2326
                                                14: distance = 129;
2327
                                                15: distance = 193;
2328
                                                16: distance = 257;
2329
                                                17: distance = 385;
2330
                                                18: distance = 513;
2331
                                                19: distance = 769;
2332
                                                20: distance = 1025;
2333
                                                21: distance = 1537;
2334
                                                22: distance = 2049;
2335
                                                23: distance = 3073;
2336
                                                24: distance = 4097;
2337
                                                25: distance = 6145;
2338
                                                26: distance = 8193;
2339
                                                27: distance = 12289;
2340
                                                28: distance = 16385;
2341
                                                default: distance = 24577;
2342
                                            endcase
2343
                                            case ($signed(distanceCode >>> 1))
2344
                                                0: moreBits = 0;
2345
                                                1: moreBits = 0;
2346
                                                2: moreBits = 1;
2347
                                                3: moreBits = 2;
2348
                                                4: moreBits = 3;
2349
                                                5: moreBits = 4;
2350
                                                6: moreBits = 5;
2351
                                                7: moreBits = 6;
2352
                                                8: moreBits = 7;
2353
                                                9: moreBits = 8;
2354
                                                10: moreBits = 9;
2355
                                                11: moreBits = 10;
2356
                                                12: moreBits = 11;
2357
                                                13: moreBits = 12;
2358
                                                default: moreBits = 13;
2359
                                            endcase
2360
                                            distance = distance + MYHDL209_get4((extraLength + 5), moreBits);
2361
                                            MYHDL210_adv(((extraLength + 5) + moreBits));
2362
                                            deflate0_0_offset <= ($signed({1'b0, deflate0_0_do}) - distance);
2363
                                            deflate0_0_length <= tlength;
2364
                                            deflate0_0_cur_i <= 0;
2365
                                            deflate0_0_oraddr <= deflate0_0_offset;
2366
                                            deflate0_0_state <= 5'b10101;
2367
                                        end
2368
                                        else begin
2369
                                            deflate0_0_state <= 5'b01111;
2370
                                        end
2371
                                    end
2372
                                    deflate0_0_cur_next <= 0;
2373
                                end
2374
                            end
2375
                            else begin
2376
                                if ((deflate0_0_state == 5'b10101)) begin
2377
                                    if ((!deflate0_0_filled)) begin
2378
                                        deflate0_0_filled <= 1'b1;
2379
                                    end
2380
                                    else if ((deflate0_0_nb < 4)) begin
2381
                                        // pass
2382
                                    end
2383
                                    else if ((deflate0_0_method == 0)) begin
2384
                                        if ((deflate0_0_cur_i < deflate0_0_length)) begin
2385
                                            deflate0_0_oaddr <= deflate0_0_do;
2386
                                            deflate0_0_obyte <= deflate0_0_b3;
2387
                                            MYHDL211_adv(8);
2388
                                            deflate0_0_cur_i <= (deflate0_0_cur_i + 1);
2389
                                            deflate0_0_do <= (deflate0_0_do + 1);
2390
                                            o_oprogress <= (deflate0_0_do + 1);
2391
                                        end
2392
                                        else if ((!deflate0_0_final)) begin
2393
                                            deflate0_0_state <= 5'b00001;
2394
                                        end
2395
                                        else begin
2396
                                            o_oprogress <= deflate0_0_do;
2397
                                            o_done <= 1'b1;
2398
                                            deflate0_0_state <= 5'b00000;
2399
                                        end
2400
                                    end
2401
                                    else if ((deflate0_0_cur_i < (deflate0_0_length + 1))) begin
2402
                                        deflate0_0_oraddr <= (deflate0_0_offset + deflate0_0_cur_i);
2403
                                        if ((deflate0_0_cur_i == 1)) begin
2404
                                            deflate0_0_copy1 <= deflate0_0_orbyte;
2405
                                        end
2406
                                        if ((deflate0_0_cur_i > 1)) begin
2407
                                            if (((deflate0_0_offset + deflate0_0_cur_i) == (deflate0_0_do + 1))) begin
2408
                                                deflate0_0_obyte <= deflate0_0_copy1;
2409
                                            end
2410
                                            else begin
2411
                                                deflate0_0_obyte <= deflate0_0_orbyte;
2412
                                            end
2413
                                            deflate0_0_oaddr <= deflate0_0_do;
2414
                                            o_oprogress <= (deflate0_0_do + 1);
2415
                                            deflate0_0_do <= (deflate0_0_do + 1);
2416
                                        end
2417
                                        deflate0_0_cur_i <= (deflate0_0_cur_i + 1);
2418
                                    end
2419
                                    else begin
2420
                                        deflate0_0_oaddr <= deflate0_0_do;
2421
                                        if (((deflate0_0_offset + deflate0_0_cur_i) == (deflate0_0_do + 1))) begin
2422
                                            deflate0_0_obyte <= deflate0_0_copy1;
2423
                                        end
2424
                                        else begin
2425
                                            deflate0_0_obyte <= deflate0_0_orbyte;
2426
                                        end
2427
                                        deflate0_0_do <= (deflate0_0_do + 1);
2428
                                        o_oprogress <= (deflate0_0_do + 1);
2429
                                        deflate0_0_cur_next <= 0;
2430
                                        deflate0_0_state <= 5'b10011;
2431
                                    end
2432
                                end
2433
                                else begin
2434
                                    $write("unknown state?!");
2435
                                    $write("\n");
2436
                                    deflate0_0_state <= 5'b00000;
2437
                                end
2438
                            end