brotli/enc/
static_dict.rs

1use core;
2pub const kNumDistanceCacheEntries: usize = 4;
3
4use super::super::dictionary::{
5    kBrotliDictionary, kBrotliDictionaryOffsetsByLength, kBrotliDictionarySizeBitsByLength,
6};
7use super::static_dict_lut::{
8    kDictHashMul32, kDictNumBits, kStaticDictionaryBuckets, kStaticDictionaryWords, DictWord,
9};
10#[allow(unused)]
11static kUppercaseFirst: u8 = 10u8;
12
13#[allow(unused)]
14static kOmitLastNTransforms: [u8; 10] = [0, 12, 27, 23, 42, 63, 56, 48, 59, 64];
15
16pub struct BrotliDictionary {
17    pub size_bits_by_length: &'static [u8; 25],
18    pub offsets_by_length: &'static [u32; 25],
19    pub data: &'static [u8; 122784],
20}
21
22pub static kBrotliEncDictionary: BrotliDictionary = BrotliDictionary {
23    size_bits_by_length: &kBrotliDictionarySizeBitsByLength,
24    offsets_by_length: &kBrotliDictionaryOffsetsByLength,
25    data: &kBrotliDictionary,
26};
27
28#[inline(always)]
29pub fn BrotliGetDictionary() -> &'static BrotliDictionary {
30    &kBrotliEncDictionary
31}
32#[inline(always)]
33pub fn BROTLI_UNALIGNED_LOAD32(sl: &[u8]) -> u32 {
34    let mut p = [0u8; 4];
35    p[..].clone_from_slice(sl.split_at(4).0);
36    (p[0] as u32) | ((p[1] as u32) << 8) | ((p[2] as u32) << 16) | ((p[3] as u32) << 24)
37}
38#[inline(always)]
39pub fn Hash(data: &[u8]) -> u32 {
40    let h: u32 = BROTLI_UNALIGNED_LOAD32(data).wrapping_mul(kDictHashMul32);
41    h >> (32i32 - kDictNumBits)
42}
43#[inline(always)]
44pub fn BROTLI_UNALIGNED_LOAD64(sl: &[u8]) -> u64 {
45    let mut p = [0u8; 8];
46    p[..].clone_from_slice(sl.split_at(8).0);
47    (p[0] as u64)
48        | ((p[1] as u64) << 8)
49        | ((p[2] as u64) << 16)
50        | ((p[3] as u64) << 24)
51        | ((p[4] as u64) << 32)
52        | ((p[5] as u64) << 40)
53        | ((p[6] as u64) << 48)
54        | ((p[7] as u64) << 56)
55}
56#[inline(always)]
57pub fn BROTLI_UNALIGNED_STORE64(outp: &mut [u8], v: u64) {
58    let p = [
59        (v & 0xff) as u8,
60        ((v >> 8) & 0xff) as u8,
61        ((v >> 16) & 0xff) as u8,
62        ((v >> 24) & 0xff) as u8,
63        ((v >> 32) & 0xff) as u8,
64        ((v >> 40) & 0xff) as u8,
65        ((v >> 48) & 0xff) as u8,
66        ((v >> 56) & 0xff) as u8,
67    ];
68    outp.split_at_mut(8).0.clone_from_slice(&p[..]);
69}
70
71macro_rules! sub_match {
72    ($s1 : expr, $s2 : expr, $limit : expr, $matched : expr, $split_pair1 : expr, $split_pair2 : expr, $s1_lo : expr, $s2_lo : expr, $s1_as_64 : expr, $s2_as_64 : expr, $vec_len: expr) => {
73        $split_pair1 = $s1.split_at($vec_len);
74        $s1_lo[..$vec_len].clone_from_slice($split_pair1.0);
75        $s1 = $split_pair1.1;
76        $split_pair2 = $s2.split_at($vec_len);
77        $s2_lo[..$vec_len].clone_from_slice($split_pair2.0);
78        $s2 = $split_pair2.1;
79        $limit -= $vec_len;
80        for index in 0..($vec_len >> 3) {
81            $s1_as_64 = BROTLI_UNALIGNED_LOAD64(&$s1_lo[(index << 3)..((index + 1) << 3)]);
82            $s2_as_64 = BROTLI_UNALIGNED_LOAD64(&$s2_lo[(index << 3)..((index + 1) << 3)]);
83            if $s2_as_64 == $s1_as_64 {
84                $matched = $matched.wrapping_add(8) as u32 as usize;
85            } else {
86                $matched = $matched
87                    .wrapping_add((($s2_as_64 ^ $s1_as_64).trailing_zeros() >> 3) as usize)
88                    as u32 as usize;
89                return $matched;
90            }
91        }
92    };
93}
94
95macro_rules! sub_match8 {
96    ($s1 : expr, $s2 : expr, $limit : expr, $matched : expr, $s1_as_64 : expr, $s2_as_64 : expr) => {
97        $limit -= 8;
98        $s1_as_64 = BROTLI_UNALIGNED_LOAD64($s1);
99        $s1 = $s1.split_at(8).1;
100        $s2_as_64 = BROTLI_UNALIGNED_LOAD64($s2);
101        $s2 = $s2.split_at(8).1;
102        if $s2_as_64 == $s1_as_64 {
103            $matched = $matched.wrapping_add(8) as u32 as usize;
104        } else {
105            $matched = $matched
106                .wrapping_add((($s2_as_64 ^ $s1_as_64).trailing_zeros() >> 3) as usize)
107                as u32 as usize;
108            return $matched;
109        }
110    };
111}
112
113// factor of 10 slower (example takes 158s, not 30, and for the 30 second run it took 15 of them)
114#[allow(unused)]
115pub fn SlowerFindMatchLengthWithLimit(s1: &[u8], s2: &[u8], limit: usize) -> usize {
116    for index in 0..limit {
117        if s1[index] != s2[index] {
118            return index;
119        }
120    }
121    limit
122}
123// factor of 5 slower (example takes 90 seconds)
124#[allow(unused)]
125pub fn FindMatchLengthWithLimit(s1: &[u8], s2: &[u8], limit: usize) -> usize {
126    for (index, pair) in s1[..limit].iter().zip(s2[..limit].iter()).enumerate() {
127        if *pair.0 != *pair.1 {
128            return index;
129        }
130    }
131    limit
132}
133#[allow(unused)]
134pub fn FindMatchLengthWithLimitMin4(s1: &[u8], s2: &[u8], limit: usize) -> usize {
135    let (s1_start, s1_rest) = s1.split_at(5);
136    let (s2_start, s2_rest) = s2.split_at(5);
137    let v0 = BROTLI_UNALIGNED_LOAD32(s1_start);
138    let v1 = BROTLI_UNALIGNED_LOAD32(s2_start);
139    let beyond_ok = s1_start[4] != s2_start[4];
140    if v0 != v1 {
141        return 0;
142    }
143    if limit <= 4 || beyond_ok {
144        return core::cmp::min(limit, 4);
145    }
146    ComplexFindMatchLengthWithLimit(s1_rest, s2_rest, limit - 5) + 5
147}
148#[inline]
149pub fn ComplexFindMatchLengthWithLimit(mut s1: &[u8], mut s2: &[u8], mut limit: usize) -> usize {
150    let mut matched: usize = 0usize;
151    let mut s1_as_64: u64;
152    let mut s2_as_64: u64;
153    if limit >= 8 {
154        sub_match8!(s1, s2, limit, matched, s1_as_64, s2_as_64);
155        if limit >= 16 {
156            let mut split_pair1: (&[u8], &[u8]);
157            let mut split_pair2: (&[u8], &[u8]);
158            {
159                let mut s1_lo = [0u8; 16];
160                let mut s1_hi = [0u8; 16];
161                sub_match!(
162                    s1,
163                    s2,
164                    limit,
165                    matched,
166                    split_pair1,
167                    split_pair2,
168                    s1_lo,
169                    s1_hi,
170                    s1_as_64,
171                    s2_as_64,
172                    16
173                );
174            }
175            if limit >= 32 {
176                let mut s1_lo_a = [0u8; 128];
177                let mut s1_hi_a = [0u8; 128];
178                sub_match!(
179                    s1,
180                    s2,
181                    limit,
182                    matched,
183                    split_pair1,
184                    split_pair2,
185                    s1_lo_a,
186                    s1_hi_a,
187                    s1_as_64,
188                    s2_as_64,
189                    32
190                );
191                if limit >= 64 {
192                    sub_match!(
193                        s1,
194                        s2,
195                        limit,
196                        matched,
197                        split_pair1,
198                        split_pair2,
199                        s1_lo_a,
200                        s1_hi_a,
201                        s1_as_64,
202                        s2_as_64,
203                        64
204                    );
205                    while limit >= 128 {
206                        sub_match!(
207                            s1,
208                            s2,
209                            limit,
210                            matched,
211                            split_pair1,
212                            split_pair2,
213                            s1_lo_a,
214                            s1_hi_a,
215                            s1_as_64,
216                            s2_as_64,
217                            128
218                        );
219                    }
220                }
221            }
222        }
223        while limit >= 8 {
224            sub_match8!(s1, s2, limit, matched, s1_as_64, s2_as_64);
225        }
226    }
227    assert!(s1.len() >= (limit & 7usize));
228    assert!(s2.len() >= (limit & 7usize));
229    for index in 0..(limit & 7usize) {
230        if s1[index] != s2[index] {
231            return matched + index;
232        }
233    }
234    matched + (limit & 7usize) // made it through the loop
235}
236
237mod test {
238    #[allow(unused)]
239    fn construct_situation(seed: &[u8], mut output: &mut [u8], limit: usize, matchfor: usize) {
240        output[..].clone_from_slice(seed);
241        if matchfor >= limit {
242            return;
243        }
244        output[matchfor] = output[matchfor].wrapping_add((matchfor as u8 % 253u8).wrapping_add(1));
245    }
246    #[test]
247    fn test_find_match_length() {
248        let mut a = [91u8; 600000];
249        let mut b = [0u8; 600000];
250        for i in 1..a.len() {
251            a[i] = (a[i - 1] % 19u8).wrapping_add(17);
252        }
253        construct_situation(&a[..], &mut b[..], a.len(), 0);
254        assert_eq!(super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()), 0);
255        construct_situation(&a[..], &mut b[..], a.len(), 1);
256        assert_eq!(super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()), 1);
257        construct_situation(&a[..], &mut b[..], a.len(), 10);
258        assert_eq!(super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()), 10);
259        construct_situation(&a[..], &mut b[..], a.len(), 9);
260        assert_eq!(super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()), 9);
261        construct_situation(&a[..], &mut b[..], a.len(), 7);
262        assert_eq!(super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()), 7);
263        construct_situation(&a[..], &mut b[..], a.len(), 8);
264        assert_eq!(super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()), 8);
265        construct_situation(&a[..], &mut b[..], a.len(), 48);
266        assert_eq!(super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()), 48);
267        construct_situation(&a[..], &mut b[..], a.len(), 49);
268        assert_eq!(super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()), 49);
269        construct_situation(&a[..], &mut b[..], a.len(), 63);
270        assert_eq!(super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()), 63);
271        construct_situation(&a[..], &mut b[..], a.len(), 222);
272        assert_eq!(
273            super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()),
274            222
275        );
276        construct_situation(&a[..], &mut b[..], a.len(), 1590);
277        assert_eq!(
278            super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()),
279            1590
280        );
281        construct_situation(&a[..], &mut b[..], a.len(), 12590);
282        assert_eq!(
283            super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()),
284            12590
285        );
286        construct_situation(&a[..], &mut b[..], a.len(), 52592);
287        assert_eq!(
288            super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()),
289            52592
290        );
291        construct_situation(&a[..], &mut b[..], a.len(), 152592);
292        assert_eq!(
293            super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()),
294            152592
295        );
296        construct_situation(&a[..], &mut b[..], a.len(), 252591);
297        assert_eq!(
298            super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()),
299            252591
300        );
301        construct_situation(&a[..], &mut b[..], a.len(), 131072);
302        assert_eq!(
303            super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()),
304            131072
305        );
306        construct_situation(&a[..], &mut b[..], a.len(), 131073);
307        assert_eq!(
308            super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()),
309            131073
310        );
311        construct_situation(&a[..], &mut b[..], a.len(), 131072 + 64 + 32 + 16 + 8);
312        assert_eq!(
313            super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()),
314            131072 + 64 + 32 + 16 + 8
315        );
316        construct_situation(&a[..], &mut b[..], a.len(), 272144 + 64 + 32 + 16 + 8 + 1);
317        assert_eq!(
318            super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()),
319            272144 + 64 + 32 + 16 + 8 + 1
320        );
321        construct_situation(&a[..], &mut b[..], a.len(), 2 * 272144 + 64 + 32 + 16 + 8);
322        assert_eq!(
323            super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()),
324            2 * 272144 + 64 + 32 + 16 + 8
325        );
326        construct_situation(&a[..], &mut b[..], a.len(), a.len());
327        assert_eq!(
328            super::FindMatchLengthWithLimit(&a[..], &b[..], a.len()),
329            a.len()
330        );
331    }
332}
333#[allow(unused)]
334pub fn slowFindMatchLengthWithLimit(s1: &[u8], s2: &[u8], limit: usize) -> usize {
335    for (index, it) in s1[..limit].iter().zip(s2[..limit].iter()).enumerate() {
336        if it.0 != it.1 {
337            return index;
338        }
339    }
340    limit
341}
342
343pub fn IsMatch(dictionary: &BrotliDictionary, w: DictWord, data: &[u8], max_length: usize) -> i32 {
344    if w.l as usize > max_length {
345        0
346    } else {
347        let offset: usize = (dictionary.offsets_by_length[w.l as usize] as usize)
348            .wrapping_add((w.len() as usize).wrapping_mul(w.idx() as usize));
349        let dict = &dictionary.data.split_at(offset).1;
350        if w.transform() as i32 == 0i32 {
351            if FindMatchLengthWithLimit(dict, data, w.l as usize) == w.l as usize {
352                1
353            } else {
354                0
355            }
356        } else if w.transform() as i32 == 10i32 {
357            if dict[0] as i32 >= b'a' as i32
358                && (dict[0] as i32 <= b'z' as i32)
359                && (dict[0] as i32 ^ 32i32 == data[0] as i32)
360                && (FindMatchLengthWithLimit(
361                    dict.split_at(1).1,
362                    data.split_at(1).1,
363                    (w.len() as u32).wrapping_sub(1) as usize,
364                ) == (w.len() as u32).wrapping_sub(1) as usize)
365            {
366                1
367            } else {
368                0
369            }
370        } else {
371            let mut i: usize;
372            i = 0usize;
373            while i < w.len() as usize {
374                {
375                    if dict[i] as i32 >= b'a' as i32 && (dict[i] as i32 <= b'z' as i32) {
376                        if dict[i] as i32 ^ 32i32 != data[i] as i32 {
377                            return 0;
378                        }
379                    } else if dict[i] as i32 != data[i] as i32 {
380                        return 0;
381                    }
382                }
383                i = i.wrapping_add(1);
384            }
385            1
386        }
387    }
388}
389
390#[allow(unused)]
391fn brotli_min_uint32_t(a: u32, b: u32) -> u32 {
392    if a < b {
393        a
394    } else {
395        b
396    }
397}
398
399#[allow(unused)]
400fn AddMatch(distance: usize, len: usize, len_code: usize, mut matches: &mut [u32]) {
401    let match_: u32 = (distance << 5).wrapping_add(len_code) as u32;
402    matches[len] = brotli_min_uint32_t(matches[len], match_);
403}
404
405#[allow(unused)]
406fn brotli_min_size_t(a: usize, b: usize) -> usize {
407    if a < b {
408        a
409    } else {
410        b
411    }
412}
413
414#[allow(unused)]
415fn DictMatchLength(
416    dictionary: &BrotliDictionary,
417    data: &[u8],
418    id: usize,
419    len: usize,
420    maxlen: usize,
421) -> usize {
422    let offset: usize =
423        (dictionary.offsets_by_length[len] as usize).wrapping_add(len.wrapping_mul(id));
424    FindMatchLengthWithLimit(
425        dictionary.data.split_at(offset).1,
426        data,
427        brotli_min_size_t(len, maxlen),
428    )
429}
430
431#[allow(unused)]
432fn brotli_max_size_t(a: usize, b: usize) -> usize {
433    if a > b {
434        a
435    } else {
436        b
437    }
438}
439
440#[allow(unused)]
441pub fn BrotliFindAllStaticDictionaryMatches(
442    dictionary: &BrotliDictionary,
443    data: &[u8],
444    min_length: usize,
445    max_length: usize,
446    mut matches: &mut [u32],
447) -> i32 {
448    let mut has_found_match: i32 = 0i32;
449    {
450        let mut offset: usize = kStaticDictionaryBuckets[Hash(data) as usize] as usize;
451        let mut end: i32 = (offset == 0) as i32;
452        while end == 0 {
453            let mut w: DictWord = kStaticDictionaryWords[offset];
454            offset = offset.wrapping_add(1);
455            let l: usize = (w.len() as i32 & 0x1fi32) as usize;
456            let n: usize = 1usize << dictionary.size_bits_by_length[l] as i32;
457            let id: usize = w.idx() as usize;
458            end = !(w.len() as i32 & 0x80i32 == 0) as i32;
459            w.l = l as u8;
460            if w.transform() as i32 == 0i32 {
461                let matchlen: usize = DictMatchLength(dictionary, data, id, l, max_length);
462
463                let mut minlen: usize;
464
465                let mut len: usize;
466                if matchlen == l {
467                    //eprint!("Adding match {} {} {}\n", w.len(), w.transform(), w.idx());
468                    AddMatch(id, l, l, matches);
469                    has_found_match = 1i32;
470                }
471                if matchlen >= l.wrapping_sub(1) {
472                    //eprint!("Bdding match {} {} {}\n", w.len(), w.transform(), w.idx());
473                    AddMatch(
474                        id.wrapping_add((12usize).wrapping_mul(n)),
475                        l.wrapping_sub(1),
476                        l,
477                        matches,
478                    );
479                    if l.wrapping_add(2) < max_length
480                        && (data[(l.wrapping_sub(1) as usize)] as i32 == b'i' as i32)
481                        && (data[(l as usize)] as i32 == b'n' as i32)
482                        && (data[(l.wrapping_add(1) as usize)] as i32 == b'g' as i32)
483                        && (data[(l.wrapping_add(2) as usize)] as i32 == b' ' as i32)
484                    {
485                        //eprint!("Cdding match {} {} {}\n", w.len(), w.transform(), w.idx());
486                        AddMatch(
487                            id.wrapping_add((49usize).wrapping_mul(n)),
488                            l.wrapping_add(3),
489                            l,
490                            matches,
491                        );
492                    }
493                    has_found_match = 1i32;
494                }
495                minlen = min_length;
496                if l > 9usize {
497                    minlen = brotli_max_size_t(minlen, l.wrapping_sub(9));
498                }
499                let maxlen: usize = brotli_min_size_t(matchlen, l.wrapping_sub(2));
500                len = minlen;
501                while len <= maxlen {
502                    {
503                        //eprint!("Ddding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
504                        AddMatch(
505                            id.wrapping_add(
506                                (kOmitLastNTransforms[l.wrapping_sub(len)] as usize)
507                                    .wrapping_mul(n),
508                            ),
509                            len,
510                            l,
511                            matches,
512                        );
513                        has_found_match = 1i32;
514                    }
515                    len = len.wrapping_add(1);
516                }
517                if matchlen < l || l.wrapping_add(6) >= max_length {
518                    {
519                        continue;
520                    }
521                }
522                let s: &[u8] = data.split_at(l as usize).1;
523                if s[0] as i32 == b' ' as i32 {
524                    //eprint!("Edding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
525                    AddMatch(id.wrapping_add(n), l.wrapping_add(1), l, matches);
526                    if s[1] as i32 == b'a' as i32 {
527                        if s[2] as i32 == b' ' as i32 {
528                            //eprint!("Fdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
529                            AddMatch(
530                                id.wrapping_add((28usize).wrapping_mul(n)),
531                                l.wrapping_add(3),
532                                l,
533                                matches,
534                            );
535                        } else if s[2] as i32 == b's' as i32 {
536                            if s[3] as i32 == b' ' as i32 {
537                                //eprint!("Gdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
538                                AddMatch(
539                                    id.wrapping_add((46usize).wrapping_mul(n)),
540                                    l.wrapping_add(4),
541                                    l,
542                                    matches,
543                                );
544                            }
545                        } else if s[2] as i32 == b't' as i32 {
546                            if s[3] as i32 == b' ' as i32 {
547                                //eprint!("Hdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
548                                AddMatch(
549                                    id.wrapping_add((60usize).wrapping_mul(n)),
550                                    l.wrapping_add(4),
551                                    l,
552                                    matches,
553                                );
554                            }
555                        } else if s[2] as i32 == b'n' as i32
556                            && s[3] as i32 == b'd' as i32
557                            && (s[4] as i32 == b' ' as i32)
558                        {
559                            //eprint!("Idding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
560                            AddMatch(
561                                id.wrapping_add((10usize).wrapping_mul(n)),
562                                l.wrapping_add(5),
563                                l,
564                                matches,
565                            );
566                        }
567                    } else if s[1] as i32 == b'b' as i32 {
568                        if s[2] as i32 == b'y' as i32 && (s[3] as i32 == b' ' as i32) {
569                            //eprint!("Jdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
570                            AddMatch(
571                                id.wrapping_add((38usize).wrapping_mul(n)),
572                                l.wrapping_add(4),
573                                l,
574                                matches,
575                            );
576                        }
577                    } else if s[1] as i32 == b'i' as i32 {
578                        if s[2] as i32 == b'n' as i32 {
579                            if s[3] as i32 == b' ' as i32 {
580                                //eprint!("Kdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
581                                AddMatch(
582                                    id.wrapping_add((16usize).wrapping_mul(n)),
583                                    l.wrapping_add(4),
584                                    l,
585                                    matches,
586                                );
587                            }
588                        } else if s[2] as i32 == b's' as i32 && s[3] as i32 == b' ' as i32 {
589                            //eprint!("Ldding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
590                            AddMatch(
591                                id.wrapping_add((47usize).wrapping_mul(n)),
592                                l.wrapping_add(4),
593                                l,
594                                matches,
595                            );
596                        }
597                    } else if s[1] as i32 == b'f' as i32 {
598                        if s[2] as i32 == b'o' as i32 {
599                            if s[3] as i32 == b'r' as i32 && (s[4] as i32 == b' ' as i32) {
600                                //eprint!("Mdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
601                                AddMatch(
602                                    id.wrapping_add((25usize).wrapping_mul(n)),
603                                    l.wrapping_add(5),
604                                    l,
605                                    matches,
606                                );
607                            }
608                        } else if s[2] as i32 == b'r' as i32
609                            && s[3] as i32 == b'o' as i32
610                            && (s[4] as i32 == b'm' as i32)
611                            && (s[5] as i32 == b' ' as i32)
612                        {
613                            //eprint!("Ndding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
614                            AddMatch(
615                                id.wrapping_add((37usize).wrapping_mul(n)),
616                                l.wrapping_add(6),
617                                l,
618                                matches,
619                            );
620                        }
621                    } else if s[1] as i32 == b'o' as i32 {
622                        if s[2] as i32 == b'f' as i32 {
623                            if s[3] as i32 == b' ' as i32 {
624                                //eprint!("Odding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
625                                AddMatch(
626                                    id.wrapping_add((8usize).wrapping_mul(n)),
627                                    l.wrapping_add(4),
628                                    l,
629                                    matches,
630                                );
631                            }
632                        } else if s[2] as i32 == b'n' as i32 && s[3] as i32 == b' ' as i32 {
633                            //eprint!("Pdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
634                            AddMatch(
635                                id.wrapping_add((45usize).wrapping_mul(n)),
636                                l.wrapping_add(4),
637                                l,
638                                matches,
639                            );
640                        }
641                    } else if s[1] as i32 == b'n' as i32 {
642                        if s[2] as i32 == b'o' as i32
643                            && (s[3] as i32 == b't' as i32)
644                            && (s[4] as i32 == b' ' as i32)
645                        {
646                            //eprint!("Qdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
647                            AddMatch(
648                                id.wrapping_add((80usize).wrapping_mul(n)),
649                                l.wrapping_add(5),
650                                l,
651                                matches,
652                            );
653                        }
654                    } else if s[1] as i32 == b't' as i32 {
655                        if s[2] as i32 == b'h' as i32 {
656                            if s[3] as i32 == b'e' as i32 {
657                                if s[4] as i32 == b' ' as i32 {
658                                    //eprint!("Rdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
659                                    AddMatch(
660                                        id.wrapping_add((5usize).wrapping_mul(n)),
661                                        l.wrapping_add(5),
662                                        l,
663                                        matches,
664                                    );
665                                }
666                            } else if s[3] as i32 == b'a' as i32
667                                && s[4] as i32 == b't' as i32
668                                && (s[5] as i32 == b' ' as i32)
669                            {
670                                //eprint!("Sdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
671                                AddMatch(
672                                    id.wrapping_add((29usize).wrapping_mul(n)),
673                                    l.wrapping_add(6),
674                                    l,
675                                    matches,
676                                );
677                            }
678                        } else if s[2] as i32 == b'o' as i32 && s[3] as i32 == b' ' as i32 {
679                            //eprint!("Tdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
680                            AddMatch(
681                                id.wrapping_add((17usize).wrapping_mul(n)),
682                                l.wrapping_add(4),
683                                l,
684                                matches,
685                            );
686                        }
687                    } else if s[1] as i32 == b'w' as i32
688                        && s[2] as i32 == b'i' as i32
689                        && (s[3] as i32 == b't' as i32)
690                        && (s[4] as i32 == b'h' as i32)
691                        && (s[5] as i32 == b' ' as i32)
692                    {
693                        //eprint!("Udding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
694                        AddMatch(
695                            id.wrapping_add((35usize).wrapping_mul(n)),
696                            l.wrapping_add(6),
697                            l,
698                            matches,
699                        );
700                    }
701                } else if s[0] as i32 == b'\"' as i32 {
702                    //eprint!("Vdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
703                    AddMatch(
704                        id.wrapping_add((19usize).wrapping_mul(n)),
705                        l.wrapping_add(1),
706                        l,
707                        matches,
708                    );
709                    if s[1] as i32 == b'>' as i32 {
710                        //eprint!("Wdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
711                        AddMatch(
712                            id.wrapping_add((21usize).wrapping_mul(n)),
713                            l.wrapping_add(2),
714                            l,
715                            matches,
716                        );
717                    }
718                } else if s[0] as i32 == b'.' as i32 {
719                    //eprint!("Xdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
720                    AddMatch(
721                        id.wrapping_add((20usize).wrapping_mul(n)),
722                        l.wrapping_add(1),
723                        l,
724                        matches,
725                    );
726                    if s[1] as i32 == b' ' as i32 {
727                        //eprint!("Ydding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
728                        AddMatch(
729                            id.wrapping_add((31usize).wrapping_mul(n)),
730                            l.wrapping_add(2),
731                            l,
732                            matches,
733                        );
734                        if s[2] as i32 == b'T' as i32 && (s[3] as i32 == b'h' as i32) {
735                            if s[4] as i32 == b'e' as i32 {
736                                if s[5] as i32 == b' ' as i32 {
737                                    //eprint!("Zdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
738                                    AddMatch(
739                                        id.wrapping_add((43usize).wrapping_mul(n)),
740                                        l.wrapping_add(6),
741                                        l,
742                                        matches,
743                                    );
744                                }
745                            } else if s[4] as i32 == b'i' as i32
746                                && s[5] as i32 == b's' as i32
747                                && (s[6] as i32 == b' ' as i32)
748                            {
749                                //eprint!("AAdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
750                                AddMatch(
751                                    id.wrapping_add((75usize).wrapping_mul(n)),
752                                    l.wrapping_add(7),
753                                    l,
754                                    matches,
755                                );
756                            }
757                        }
758                    }
759                } else if s[0] as i32 == b',' as i32 {
760                    //eprint!("ABdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
761                    AddMatch(
762                        id.wrapping_add((76usize).wrapping_mul(n)),
763                        l.wrapping_add(1),
764                        l,
765                        matches,
766                    );
767                    if s[1] as i32 == b' ' as i32 {
768                        //eprint!("ACdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
769                        AddMatch(
770                            id.wrapping_add((14usize).wrapping_mul(n)),
771                            l.wrapping_add(2),
772                            l,
773                            matches,
774                        );
775                    }
776                } else if s[0] as i32 == b'\n' as i32 {
777                    //eprint!("ADdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
778                    AddMatch(
779                        id.wrapping_add((22usize).wrapping_mul(n)),
780                        l.wrapping_add(1),
781                        l,
782                        matches,
783                    );
784                    if s[1] as i32 == b'\t' as i32 {
785                        //eprint!("AEdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
786                        AddMatch(
787                            id.wrapping_add((50usize).wrapping_mul(n)),
788                            l.wrapping_add(2),
789                            l,
790                            matches,
791                        );
792                    }
793                } else if s[0] as i32 == b']' as i32 {
794                    //eprint!("AFdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
795                    AddMatch(
796                        id.wrapping_add((24usize).wrapping_mul(n)),
797                        l.wrapping_add(1),
798                        l,
799                        matches,
800                    );
801                } else if s[0] as i32 == b'\'' as i32 {
802                    //eprint!("AGdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
803                    AddMatch(
804                        id.wrapping_add((36usize).wrapping_mul(n)),
805                        l.wrapping_add(1),
806                        l,
807                        matches,
808                    );
809                } else if s[0] as i32 == b':' as i32 {
810                    //eprint!("AHdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
811                    AddMatch(
812                        id.wrapping_add((51usize).wrapping_mul(n)),
813                        l.wrapping_add(1),
814                        l,
815                        matches,
816                    );
817                } else if s[0] as i32 == b'(' as i32 {
818                    //eprint!("AIdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
819                    AddMatch(
820                        id.wrapping_add((57usize).wrapping_mul(n)),
821                        l.wrapping_add(1),
822                        l,
823                        matches,
824                    );
825                } else if s[0] as i32 == b'=' as i32 {
826                    if s[1] as i32 == b'\"' as i32 {
827                        //eprint!("AJdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
828                        AddMatch(
829                            id.wrapping_add((70usize).wrapping_mul(n)),
830                            l.wrapping_add(2),
831                            l,
832                            matches,
833                        );
834                    } else if s[1] as i32 == b'\'' as i32 {
835                        //eprint!("AKdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
836                        AddMatch(
837                            id.wrapping_add((86usize).wrapping_mul(n)),
838                            l.wrapping_add(2),
839                            l,
840                            matches,
841                        );
842                    }
843                } else if s[0] as i32 == b'a' as i32 {
844                    if s[1] as i32 == b'l' as i32 && (s[2] as i32 == b' ' as i32) {
845                        //eprint!("ALdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
846                        AddMatch(
847                            id.wrapping_add((84usize).wrapping_mul(n)),
848                            l.wrapping_add(3),
849                            l,
850                            matches,
851                        );
852                    }
853                } else if s[0] as i32 == b'e' as i32 {
854                    if s[1] as i32 == b'd' as i32 {
855                        if s[2] as i32 == b' ' as i32 {
856                            //eprint!("AMdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
857                            AddMatch(
858                                id.wrapping_add((53usize).wrapping_mul(n)),
859                                l.wrapping_add(3),
860                                l,
861                                matches,
862                            );
863                        }
864                    } else if s[1] as i32 == b'r' as i32 {
865                        if s[2] as i32 == b' ' as i32 {
866                            //eprint!("ANdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
867                            AddMatch(
868                                id.wrapping_add((82usize).wrapping_mul(n)),
869                                l.wrapping_add(3),
870                                l,
871                                matches,
872                            );
873                        }
874                    } else if s[1] as i32 == b's' as i32
875                        && s[2] as i32 == b't' as i32
876                        && (s[3] as i32 == b' ' as i32)
877                    {
878                        //eprint!("AOdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
879                        AddMatch(
880                            id.wrapping_add((95usize).wrapping_mul(n)),
881                            l.wrapping_add(4),
882                            l,
883                            matches,
884                        );
885                    }
886                } else if s[0] as i32 == b'f' as i32 {
887                    if s[1] as i32 == b'u' as i32
888                        && (s[2] as i32 == b'l' as i32)
889                        && (s[3] as i32 == b' ' as i32)
890                    {
891                        //eprint!("APdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
892                        AddMatch(
893                            id.wrapping_add((90usize).wrapping_mul(n)),
894                            l.wrapping_add(4),
895                            l,
896                            matches,
897                        );
898                    }
899                } else if s[0] as i32 == b'i' as i32 {
900                    if s[1] as i32 == b'v' as i32 {
901                        if s[2] as i32 == b'e' as i32 && (s[3] as i32 == b' ' as i32) {
902                            //eprint!("AQdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
903                            AddMatch(
904                                id.wrapping_add((92usize).wrapping_mul(n)),
905                                l.wrapping_add(4),
906                                l,
907                                matches,
908                            );
909                        }
910                    } else if s[1] as i32 == b'z' as i32
911                        && s[2] as i32 == b'e' as i32
912                        && (s[3] as i32 == b' ' as i32)
913                    {
914                        //eprint!("ARdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
915                        AddMatch(
916                            id.wrapping_add((100usize).wrapping_mul(n)),
917                            l.wrapping_add(4),
918                            l,
919                            matches,
920                        );
921                    }
922                } else if s[0] as i32 == b'l' as i32 {
923                    if s[1] as i32 == b'e' as i32 {
924                        if s[2] as i32 == b's' as i32
925                            && (s[3] as i32 == b's' as i32)
926                            && (s[4] as i32 == b' ' as i32)
927                        {
928                            //eprint!("ASdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
929                            AddMatch(
930                                id.wrapping_add((93usize).wrapping_mul(n)),
931                                l.wrapping_add(5),
932                                l,
933                                matches,
934                            );
935                        }
936                    } else if s[1] as i32 == b'y' as i32 && s[2] as i32 == b' ' as i32 {
937                        //eprint!("ATdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
938                        AddMatch(
939                            id.wrapping_add((61usize).wrapping_mul(n)),
940                            l.wrapping_add(3),
941                            l,
942                            matches,
943                        );
944                    }
945                } else if s[0] as i32 == b'o' as i32
946                    && s[1] as i32 == b'u' as i32
947                    && (s[2] as i32 == b's' as i32)
948                    && (s[3] as i32 == b' ' as i32)
949                {
950                    //eprint!("AUdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), len);
951                    AddMatch(
952                        id.wrapping_add((106usize).wrapping_mul(n)),
953                        l.wrapping_add(4),
954                        l,
955                        matches,
956                    );
957                }
958            } else {
959                let is_all_caps = w.transform() != kUppercaseFirst;
960
961                if IsMatch(dictionary, w, data, max_length) == 0 {
962                    continue;
963                }
964                //eprint!("AVdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
965                AddMatch(
966                    id.wrapping_add((if is_all_caps { 44usize } else { 9usize }).wrapping_mul(n)),
967                    l,
968                    l,
969                    matches,
970                );
971                has_found_match = 1i32;
972                if l.wrapping_add(1) >= max_length {
973                    continue;
974                }
975                let s: &[u8] = data.split_at(l as usize).1;
976                if s[0] as i32 == b' ' as i32 {
977                    //eprint!("AWdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
978                    AddMatch(
979                        id.wrapping_add(
980                            (if is_all_caps { 68usize } else { 4usize }).wrapping_mul(n),
981                        ),
982                        l.wrapping_add(1),
983                        l,
984                        matches,
985                    );
986                } else if s[0] as i32 == b'\"' as i32 {
987                    //eprint!("AXdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
988                    AddMatch(
989                        id.wrapping_add(
990                            (if is_all_caps { 87usize } else { 66usize }).wrapping_mul(n),
991                        ),
992                        l.wrapping_add(1),
993                        l,
994                        matches,
995                    );
996                    if s[1] as i32 == b'>' as i32 {
997                        //eprint!("AYdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
998                        AddMatch(
999                            id.wrapping_add(
1000                                (if is_all_caps { 97usize } else { 69usize }).wrapping_mul(n),
1001                            ),
1002                            l.wrapping_add(2),
1003                            l,
1004                            matches,
1005                        );
1006                    }
1007                } else if s[0] as i32 == b'.' as i32 {
1008                    //eprint!("AZdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1009                    AddMatch(
1010                        id.wrapping_add(
1011                            (if is_all_caps { 101usize } else { 79usize }).wrapping_mul(n),
1012                        ),
1013                        l.wrapping_add(1),
1014                        l,
1015                        matches,
1016                    );
1017                    if s[1] as i32 == b' ' as i32 {
1018                        //eprint!("BAdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1019                        AddMatch(
1020                            id.wrapping_add(
1021                                (if is_all_caps { 114usize } else { 88usize }).wrapping_mul(n),
1022                            ),
1023                            l.wrapping_add(2),
1024                            l,
1025                            matches,
1026                        );
1027                    }
1028                } else if s[0] as i32 == b',' as i32 {
1029                    //eprint!("BBdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1030                    AddMatch(
1031                        id.wrapping_add(
1032                            (if is_all_caps { 112usize } else { 99usize }).wrapping_mul(n),
1033                        ),
1034                        l.wrapping_add(1),
1035                        l,
1036                        matches,
1037                    );
1038                    if s[1] as i32 == b' ' as i32 {
1039                        //eprint!("BCdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1040                        AddMatch(
1041                            id.wrapping_add(
1042                                (if is_all_caps { 107usize } else { 58usize }).wrapping_mul(n),
1043                            ),
1044                            l.wrapping_add(2),
1045                            l,
1046                            matches,
1047                        );
1048                    }
1049                } else if s[0] as i32 == b'\'' as i32 {
1050                    //eprint!("BDdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1051                    AddMatch(
1052                        id.wrapping_add(
1053                            (if is_all_caps { 94usize } else { 74usize }).wrapping_mul(n),
1054                        ),
1055                        l.wrapping_add(1),
1056                        l,
1057                        matches,
1058                    );
1059                } else if s[0] as i32 == b'(' as i32 {
1060                    //eprint!("BEdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1061                    AddMatch(
1062                        id.wrapping_add(
1063                            (if is_all_caps { 113usize } else { 78usize }).wrapping_mul(n),
1064                        ),
1065                        l.wrapping_add(1),
1066                        l,
1067                        matches,
1068                    );
1069                } else if s[0] as i32 == b'=' as i32 {
1070                    if s[1] as i32 == b'\"' as i32 {
1071                        //eprint!("BFdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1072                        AddMatch(
1073                            id.wrapping_add(
1074                                (if is_all_caps { 105usize } else { 104usize }).wrapping_mul(n),
1075                            ),
1076                            l.wrapping_add(2),
1077                            l,
1078                            matches,
1079                        );
1080                    } else if s[1] as i32 == b'\'' as i32 {
1081                        //eprint!("BGdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1082                        AddMatch(
1083                            id.wrapping_add(
1084                                (if is_all_caps { 116usize } else { 108usize }).wrapping_mul(n),
1085                            ),
1086                            l.wrapping_add(2),
1087                            l,
1088                            matches,
1089                        );
1090                    }
1091                }
1092            }
1093        }
1094    }
1095    if max_length >= 5usize && (data[0] as i32 == b' ' as i32 || data[0] as i32 == b'.' as i32) {
1096        let is_space = data[0] == b' ';
1097        let mut offset: usize =
1098            kStaticDictionaryBuckets[Hash(data.split_at(1).1) as usize] as usize;
1099        let mut end: i32 = (offset == 0) as i32;
1100        while end == 0 {
1101            let mut w: DictWord = kStaticDictionaryWords[offset];
1102            offset = offset.wrapping_add(1);
1103            let l: usize = (w.len() as i32 & 0x1fi32) as usize;
1104            let n: usize = 1usize << dictionary.size_bits_by_length[l] as i32;
1105            let id: usize = w.idx() as usize;
1106            end = !(w.len() as i32 & 0x80i32 == 0) as i32;
1107            w.l = l as u8;
1108            if w.transform() as i32 == 0i32 {
1109                if IsMatch(
1110                    dictionary,
1111                    w,
1112                    data.split_at(1).1,
1113                    max_length.wrapping_sub(1),
1114                ) == 0
1115                {
1116                    continue;
1117                }
1118                //eprint!("BHdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1119                AddMatch(
1120                    id.wrapping_add((if is_space { 6usize } else { 32usize }).wrapping_mul(n)),
1121                    l.wrapping_add(1),
1122                    l,
1123                    matches,
1124                );
1125                has_found_match = 1i32;
1126                if l.wrapping_add(2) >= max_length {
1127                    {
1128                        continue;
1129                    }
1130                }
1131                let s: &[u8] = data.split_at(l.wrapping_add(1) as usize).1;
1132                if s[0] as i32 == b' ' as i32 {
1133                    //eprint!("BIdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1134                    AddMatch(
1135                        id.wrapping_add((if is_space { 2usize } else { 77usize }).wrapping_mul(n)),
1136                        l.wrapping_add(2),
1137                        l,
1138                        matches,
1139                    );
1140                } else if s[0] as i32 == b'(' as i32 {
1141                    //eprint!("BJdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1142                    AddMatch(
1143                        id.wrapping_add((if is_space { 89usize } else { 67usize }).wrapping_mul(n)),
1144                        l.wrapping_add(2),
1145                        l,
1146                        matches,
1147                    );
1148                } else if is_space {
1149                    if s[0] as i32 == b',' as i32 {
1150                        //eprint!("BKdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1151                        AddMatch(
1152                            id.wrapping_add((103usize).wrapping_mul(n)),
1153                            l.wrapping_add(2),
1154                            l,
1155                            matches,
1156                        );
1157                        if s[1] as i32 == b' ' as i32 {
1158                            //eprint!("BLdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1159                            AddMatch(
1160                                id.wrapping_add((33usize).wrapping_mul(n)),
1161                                l.wrapping_add(3),
1162                                l,
1163                                matches,
1164                            );
1165                        }
1166                    } else if s[0] as i32 == b'.' as i32 {
1167                        //eprint!("BMdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1168                        AddMatch(
1169                            id.wrapping_add((71usize).wrapping_mul(n)),
1170                            l.wrapping_add(2),
1171                            l,
1172                            matches,
1173                        );
1174                        if s[1] as i32 == b' ' as i32 {
1175                            //eprint!("BNdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1176                            AddMatch(
1177                                id.wrapping_add((52usize).wrapping_mul(n)),
1178                                l.wrapping_add(3),
1179                                l,
1180                                matches,
1181                            );
1182                        }
1183                    } else if s[0] as i32 == b'=' as i32 {
1184                        if s[1] as i32 == b'\"' as i32 {
1185                            //eprint!("BOdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1186                            AddMatch(
1187                                id.wrapping_add((81usize).wrapping_mul(n)),
1188                                l.wrapping_add(3),
1189                                l,
1190                                matches,
1191                            );
1192                        } else if s[1] as i32 == b'\'' as i32 {
1193                            //eprint!("BPdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1194                            AddMatch(
1195                                id.wrapping_add((98usize).wrapping_mul(n)),
1196                                l.wrapping_add(3),
1197                                l,
1198                                matches,
1199                            );
1200                        }
1201                    }
1202                }
1203            } else if is_space {
1204                let is_all_caps = w.transform() != kUppercaseFirst;
1205
1206                if IsMatch(
1207                    dictionary,
1208                    w,
1209                    data.split_at(1).1,
1210                    max_length.wrapping_sub(1),
1211                ) == 0
1212                {
1213                    continue;
1214                }
1215                //eprint!("CAdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1216                AddMatch(
1217                    id.wrapping_add((if is_all_caps { 85usize } else { 30usize }).wrapping_mul(n)),
1218                    l.wrapping_add(1),
1219                    l,
1220                    matches,
1221                );
1222                has_found_match = 1i32;
1223                if l.wrapping_add(2) >= max_length {
1224                    {
1225                        continue;
1226                    }
1227                }
1228                let s: &[u8] = data.split_at(l.wrapping_add(1)).1;
1229                if s[0] as i32 == b' ' as i32 {
1230                    //eprint!("CBdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1231                    AddMatch(
1232                        id.wrapping_add(
1233                            (if is_all_caps { 83usize } else { 15usize }).wrapping_mul(n),
1234                        ),
1235                        l.wrapping_add(2),
1236                        l,
1237                        matches,
1238                    );
1239                } else if s[0] as i32 == b',' as i32 {
1240                    if !is_all_caps {
1241                        //eprint!("CCdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1242                        AddMatch(
1243                            id.wrapping_add((109usize).wrapping_mul(n)),
1244                            l.wrapping_add(2),
1245                            l,
1246                            matches,
1247                        );
1248                    }
1249                    if s[1] as i32 == b' ' as i32 {
1250                        //eprint!("CDdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1251                        AddMatch(
1252                            id.wrapping_add(
1253                                (if is_all_caps { 111usize } else { 65usize }).wrapping_mul(n),
1254                            ),
1255                            l.wrapping_add(3),
1256                            l,
1257                            matches,
1258                        );
1259                    }
1260                } else if s[0] as i32 == b'.' as i32 {
1261                    //eprint!("CEdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1262                    AddMatch(
1263                        id.wrapping_add(
1264                            (if is_all_caps { 115usize } else { 96usize }).wrapping_mul(n),
1265                        ),
1266                        l.wrapping_add(2),
1267                        l,
1268                        matches,
1269                    );
1270                    if s[1] as i32 == b' ' as i32 {
1271                        //eprint!("CFdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1272                        AddMatch(
1273                            id.wrapping_add(
1274                                (if is_all_caps { 117usize } else { 91usize }).wrapping_mul(n),
1275                            ),
1276                            l.wrapping_add(3),
1277                            l,
1278                            matches,
1279                        );
1280                    }
1281                } else if s[0] as i32 == b'=' as i32 {
1282                    if s[1] as i32 == b'\"' as i32 {
1283                        //eprint!("CGdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1284                        AddMatch(
1285                            id.wrapping_add(
1286                                (if is_all_caps { 110usize } else { 118usize }).wrapping_mul(n),
1287                            ),
1288                            l.wrapping_add(3),
1289                            l,
1290                            matches,
1291                        );
1292                    } else if s[1] as i32 == b'\'' as i32 {
1293                        //eprint!("CHdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1294                        AddMatch(
1295                            id.wrapping_add(
1296                                (if is_all_caps { 119usize } else { 120usize }).wrapping_mul(n),
1297                            ),
1298                            l.wrapping_add(3),
1299                            l,
1300                            matches,
1301                        );
1302                    }
1303                }
1304            }
1305        }
1306    }
1307    if max_length >= 6usize
1308        && (data[1] as i32 == b' ' as i32
1309            && (data[0] as i32 == b'e' as i32
1310                || data[0] as i32 == b's' as i32
1311                || data[0] as i32 == b',' as i32)
1312            || data[0] as i32 == 0xc2i32 && (data[1] as i32 == 0xa0i32))
1313    {
1314        let mut offset: usize =
1315            kStaticDictionaryBuckets[Hash(data.split_at(2).1) as usize] as usize;
1316        let mut end: i32 = (offset == 0) as i32;
1317        while end == 0 {
1318            let mut w: DictWord = kStaticDictionaryWords[offset];
1319            offset = offset.wrapping_add(1);
1320            let l: usize = (w.len() as i32 & 0x1fi32) as usize;
1321            let n: usize = 1usize << dictionary.size_bits_by_length[l] as i32;
1322            let id: usize = w.idx() as usize;
1323            end = !(w.len() as i32 & 0x80i32 == 0) as i32;
1324            w.l = l as u8;
1325            if w.transform() as i32 == 0i32
1326                && (IsMatch(
1327                    dictionary,
1328                    w,
1329                    data.split_at(2).1,
1330                    max_length.wrapping_sub(2),
1331                ) != 0)
1332            {
1333                if data[0] as i32 == 0xc2i32 {
1334                    //eprint!("CIdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1335                    AddMatch(
1336                        id.wrapping_add((102usize).wrapping_mul(n)),
1337                        l.wrapping_add(2),
1338                        l,
1339                        matches,
1340                    );
1341                    has_found_match = 1i32;
1342                } else if l.wrapping_add(2) < max_length
1343                    && (data[(l.wrapping_add(2) as usize)] as i32 == b' ' as i32)
1344                {
1345                    let t: usize = (if data[0] as i32 == b'e' as i32 {
1346                        18i32
1347                    } else if data[0] as i32 == b's' as i32 {
1348                        7i32
1349                    } else {
1350                        13i32
1351                    }) as usize;
1352                    //eprint!("CJdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1353                    AddMatch(
1354                        id.wrapping_add(t.wrapping_mul(n)),
1355                        l.wrapping_add(3),
1356                        l,
1357                        matches,
1358                    );
1359                    has_found_match = 1i32;
1360                }
1361            }
1362        }
1363    }
1364    if max_length >= 9usize
1365        && (data[0] as i32 == b' ' as i32
1366            && (data[1] as i32 == b't' as i32)
1367            && (data[2] as i32 == b'h' as i32)
1368            && (data[3] as i32 == b'e' as i32)
1369            && (data[4] as i32 == b' ' as i32)
1370            || data[0] as i32 == b'.' as i32
1371                && (data[1] as i32 == b'c' as i32)
1372                && (data[2] as i32 == b'o' as i32)
1373                && (data[3] as i32 == b'm' as i32)
1374                && (data[4] as i32 == b'/' as i32))
1375    {
1376        let mut offset: usize =
1377            kStaticDictionaryBuckets[Hash(data.split_at(5).1) as usize] as usize;
1378        let mut end: i32 = (offset == 0) as i32;
1379        while end == 0 {
1380            let mut w: DictWord = kStaticDictionaryWords[offset];
1381            offset = offset.wrapping_add(1);
1382            let l: usize = (w.len() as i32 & 0x1fi32) as usize;
1383            let n: usize = 1usize << dictionary.size_bits_by_length[l] as i32;
1384            let id: usize = w.idx() as usize;
1385            end = !(w.len() as i32 & 0x80i32 == 0) as i32;
1386            w.l = l as u8;
1387            if w.transform() as i32 == 0i32
1388                && (IsMatch(
1389                    dictionary,
1390                    w,
1391                    data.split_at(5).1,
1392                    max_length.wrapping_sub(5),
1393                ) != 0)
1394            {
1395                //eprint!("CKdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1396                AddMatch(
1397                    id.wrapping_add(
1398                        (if data[0] as i32 == b' ' as i32 {
1399                            41i32
1400                        } else {
1401                            72i32
1402                        } as usize)
1403                            .wrapping_mul(n),
1404                    ),
1405                    l.wrapping_add(5),
1406                    l,
1407                    matches,
1408                );
1409                has_found_match = 1i32;
1410                if l.wrapping_add(5) < max_length {
1411                    let s: &[u8] = data.split_at(l.wrapping_add(5) as usize).1;
1412                    if data[0] as i32 == b' ' as i32
1413                        && l.wrapping_add(8) < max_length
1414                        && (s[0] as i32 == b' ' as i32)
1415                        && (s[1] as i32 == b'o' as i32)
1416                        && (s[2] as i32 == b'f' as i32)
1417                        && (s[3] as i32 == b' ' as i32)
1418                    {
1419                        //eprint!("CLdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1420                        AddMatch(
1421                            id.wrapping_add((62usize).wrapping_mul(n)),
1422                            l.wrapping_add(9),
1423                            l,
1424                            matches,
1425                        );
1426                        if l.wrapping_add(12) < max_length
1427                            && (s[4] as i32 == b't' as i32)
1428                            && (s[5] as i32 == b'h' as i32)
1429                            && (s[6] as i32 == b'e' as i32)
1430                            && (s[7] as i32 == b' ' as i32)
1431                        {
1432                            //eprint!("BQdding match {} {} {} {}\n", w.len(), w.transform(), w.idx(), 666);
1433                            AddMatch(
1434                                id.wrapping_add((73usize).wrapping_mul(n)),
1435                                l.wrapping_add(13),
1436                                l,
1437                                matches,
1438                            );
1439                        }
1440                    }
1441                }
1442            }
1443        }
1444    }
1445    has_found_match
1446}
brotli/enc/static_dict.rs

brotli/enc/
static_dict.rs
