Imported Upstream version 1.2.2-1
[packages/binwalk.git] / magic / lzma
1
2 # ------------------------------------------------------------------
3 # Signature for LZMA compressed data with valid properties byte 0x40
4 # ------------------------------------------------------------------
5 0               string  \x40\x00\x00    LZMA compressed data, properties: 0x40,
6
7 # These are all the valid dictionary sizes supported by LZMA utils.
8 >1              lelong  !65536  
9 >>1             lelong  !131072 
10 >>>1            lelong  !262144 
11 >>>>1           lelong  !524288 
12 >>>>>1          lelong  !1048576        
13 >>>>>>1         lelong  !2097152        
14 >>>>>>>1        lelong  !4194304        
15 >>>>>>>>1       lelong  !8388608        
16 >>>>>>>>>1      lelong  !16777216       
17 >>>>>>>>>>1     lelong  !33554432       invalid
18 >1              lelong  x               dictionary size: %d bytes,
19
20 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
21 # This could technically be valid, but is unlikely.
22 >5              lequad  !-1
23 >>5             lequad  <32             invalid
24 >>5             lequad  >0x40000000     invalid
25
26 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
27 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
28 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
29 >1              lelong  65536
30 >>5             lequad  65536           invalid
31 >1              lelong  131072
32 >>5             lequad  131072          invalid
33 >1              lelong  262144
34 >>5             lequad  262144          invalid
35 >1              lelong  524288
36 >>5             lequad  524288          invalid
37 >1              lelong  1048576
38 >>5             lequad  1048576         invalid
39 >1              lelong  2097152
40 >>5             lequad  2097152         invalid
41 >1              lelong  4194304
42 >>5             lequad  4194304         invalid
43 >1              lelong  8388608
44 >>5             lequad  8388608         invalid
45 >1              lelong  16777216
46 >>5             lequad  16777216        invalid
47 >1              lelong  33554432
48 >>5             lequad  33554432        invalid
49 >5              lequad  x               uncompressed size: %lld bytes
50
51
52 # ------------------------------------------------------------------
53 # Signature for LZMA compressed data with valid properties byte 0x41
54 # ------------------------------------------------------------------
55 0               string  \x41\x00\x00    LZMA compressed data, properties: 0x41,
56
57 # These are all the valid dictionary sizes supported by LZMA utils.
58 >1              lelong  !65536  
59 >>1             lelong  !131072 
60 >>>1            lelong  !262144 
61 >>>>1           lelong  !524288 
62 >>>>>1          lelong  !1048576        
63 >>>>>>1         lelong  !2097152        
64 >>>>>>>1        lelong  !4194304        
65 >>>>>>>>1       lelong  !8388608        
66 >>>>>>>>>1      lelong  !16777216       
67 >>>>>>>>>>1     lelong  !33554432       invalid
68 >1              lelong  x               dictionary size: %d bytes,
69
70 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
71 # This could technically be valid, but is unlikely.
72 >5              lequad  !-1
73 >>5             lequad  <32             invalid
74 >>5             lequad  >0x40000000     invalid
75
76 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
77 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
78 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
79 >1              lelong  65536
80 >>5             lequad  65536           invalid
81 >1              lelong  131072
82 >>5             lequad  131072          invalid
83 >1              lelong  262144
84 >>5             lequad  262144          invalid
85 >1              lelong  524288
86 >>5             lequad  524288          invalid
87 >1              lelong  1048576
88 >>5             lequad  1048576         invalid
89 >1              lelong  2097152
90 >>5             lequad  2097152         invalid
91 >1              lelong  4194304
92 >>5             lequad  4194304         invalid
93 >1              lelong  8388608
94 >>5             lequad  8388608         invalid
95 >1              lelong  16777216
96 >>5             lequad  16777216        invalid
97 >1              lelong  33554432
98 >>5             lequad  33554432        invalid
99 >5              lequad  x               uncompressed size: %lld bytes
100
101
102 # ------------------------------------------------------------------
103 # Signature for LZMA compressed data with valid properties byte 0x48
104 # ------------------------------------------------------------------
105 0               string  \x48\x00\x00    LZMA compressed data, properties: 0x48,
106
107 # These are all the valid dictionary sizes supported by LZMA utils.
108 >1              lelong  !65536  
109 >>1             lelong  !131072 
110 >>>1            lelong  !262144 
111 >>>>1           lelong  !524288 
112 >>>>>1          lelong  !1048576        
113 >>>>>>1         lelong  !2097152        
114 >>>>>>>1        lelong  !4194304        
115 >>>>>>>>1       lelong  !8388608        
116 >>>>>>>>>1      lelong  !16777216       
117 >>>>>>>>>>1     lelong  !33554432       invalid
118 >1              lelong  x               dictionary size: %d bytes,
119
120 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
121 # This could technically be valid, but is unlikely.
122 >5              lequad  !-1
123 >>5             lequad  <32             invalid
124 >>5             lequad  >0x40000000     invalid
125
126 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
127 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
128 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
129 >1              lelong  65536
130 >>5             lequad  65536           invalid
131 >1              lelong  131072
132 >>5             lequad  131072          invalid
133 >1              lelong  262144
134 >>5             lequad  262144          invalid
135 >1              lelong  524288
136 >>5             lequad  524288          invalid
137 >1              lelong  1048576
138 >>5             lequad  1048576         invalid
139 >1              lelong  2097152
140 >>5             lequad  2097152         invalid
141 >1              lelong  4194304
142 >>5             lequad  4194304         invalid
143 >1              lelong  8388608
144 >>5             lequad  8388608         invalid
145 >1              lelong  16777216
146 >>5             lequad  16777216        invalid
147 >1              lelong  33554432
148 >>5             lequad  33554432        invalid
149 >5              lequad  x               uncompressed size: %lld bytes
150
151
152 # ------------------------------------------------------------------
153 # Signature for LZMA compressed data with valid properties byte 0x49
154 # ------------------------------------------------------------------
155 0               string  \x49\x00\x00    LZMA compressed data, properties: 0x49,
156
157 # These are all the valid dictionary sizes supported by LZMA utils.
158 >1              lelong  !65536  
159 >>1             lelong  !131072 
160 >>>1            lelong  !262144 
161 >>>>1           lelong  !524288 
162 >>>>>1          lelong  !1048576        
163 >>>>>>1         lelong  !2097152        
164 >>>>>>>1        lelong  !4194304        
165 >>>>>>>>1       lelong  !8388608        
166 >>>>>>>>>1      lelong  !16777216       
167 >>>>>>>>>>1     lelong  !33554432       invalid
168 >1              lelong  x               dictionary size: %d bytes,
169
170 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
171 # This could technically be valid, but is unlikely.
172 >5              lequad  !-1
173 >>5             lequad  <32             invalid
174 >>5             lequad  >0x40000000     invalid
175
176 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
177 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
178 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
179 >1              lelong  65536
180 >>5             lequad  65536           invalid
181 >1              lelong  131072
182 >>5             lequad  131072          invalid
183 >1              lelong  262144
184 >>5             lequad  262144          invalid
185 >1              lelong  524288
186 >>5             lequad  524288          invalid
187 >1              lelong  1048576
188 >>5             lequad  1048576         invalid
189 >1              lelong  2097152
190 >>5             lequad  2097152         invalid
191 >1              lelong  4194304
192 >>5             lequad  4194304         invalid
193 >1              lelong  8388608
194 >>5             lequad  8388608         invalid
195 >1              lelong  16777216
196 >>5             lequad  16777216        invalid
197 >1              lelong  33554432
198 >>5             lequad  33554432        invalid
199 >5              lequad  x               uncompressed size: %lld bytes
200
201
202 # ------------------------------------------------------------------
203 # Signature for LZMA compressed data with valid properties byte 0x51
204 # ------------------------------------------------------------------
205 0               string  \x51\x00\x00    LZMA compressed data, properties: 0x51,
206
207 # These are all the valid dictionary sizes supported by LZMA utils.
208 >1              lelong  !65536  
209 >>1             lelong  !131072 
210 >>>1            lelong  !262144 
211 >>>>1           lelong  !524288 
212 >>>>>1          lelong  !1048576        
213 >>>>>>1         lelong  !2097152        
214 >>>>>>>1        lelong  !4194304        
215 >>>>>>>>1       lelong  !8388608        
216 >>>>>>>>>1      lelong  !16777216       
217 >>>>>>>>>>1     lelong  !33554432       invalid
218 >1              lelong  x               dictionary size: %d bytes,
219
220 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
221 # This could technically be valid, but is unlikely.
222 >5              lequad  !-1
223 >>5             lequad  <32             invalid
224 >>5             lequad  >0x40000000     invalid
225
226 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
227 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
228 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
229 >1              lelong  65536
230 >>5             lequad  65536           invalid
231 >1              lelong  131072
232 >>5             lequad  131072          invalid
233 >1              lelong  262144
234 >>5             lequad  262144          invalid
235 >1              lelong  524288
236 >>5             lequad  524288          invalid
237 >1              lelong  1048576
238 >>5             lequad  1048576         invalid
239 >1              lelong  2097152
240 >>5             lequad  2097152         invalid
241 >1              lelong  4194304
242 >>5             lequad  4194304         invalid
243 >1              lelong  8388608
244 >>5             lequad  8388608         invalid
245 >1              lelong  16777216
246 >>5             lequad  16777216        invalid
247 >1              lelong  33554432
248 >>5             lequad  33554432        invalid
249 >5              lequad  x               uncompressed size: %lld bytes
250
251
252 # ------------------------------------------------------------------
253 # Signature for LZMA compressed data with valid properties byte 0x5A
254 # ------------------------------------------------------------------
255 0               string  \x5A\x00\x00    LZMA compressed data, properties: 0x5A,
256
257 # These are all the valid dictionary sizes supported by LZMA utils.
258 >1              lelong  !65536  
259 >>1             lelong  !131072 
260 >>>1            lelong  !262144 
261 >>>>1           lelong  !524288 
262 >>>>>1          lelong  !1048576        
263 >>>>>>1         lelong  !2097152        
264 >>>>>>>1        lelong  !4194304        
265 >>>>>>>>1       lelong  !8388608        
266 >>>>>>>>>1      lelong  !16777216       
267 >>>>>>>>>>1     lelong  !33554432       invalid
268 >1              lelong  x               dictionary size: %d bytes,
269
270 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
271 # This could technically be valid, but is unlikely.
272 >5              lequad  !-1
273 >>5             lequad  <32             invalid
274 >>5             lequad  >0x40000000     invalid
275
276 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
277 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
278 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
279 >1              lelong  65536
280 >>5             lequad  65536           invalid
281 >1              lelong  131072
282 >>5             lequad  131072          invalid
283 >1              lelong  262144
284 >>5             lequad  262144          invalid
285 >1              lelong  524288
286 >>5             lequad  524288          invalid
287 >1              lelong  1048576
288 >>5             lequad  1048576         invalid
289 >1              lelong  2097152
290 >>5             lequad  2097152         invalid
291 >1              lelong  4194304
292 >>5             lequad  4194304         invalid
293 >1              lelong  8388608
294 >>5             lequad  8388608         invalid
295 >1              lelong  16777216
296 >>5             lequad  16777216        invalid
297 >1              lelong  33554432
298 >>5             lequad  33554432        invalid
299 >5              lequad  x               uncompressed size: %lld bytes
300
301
302 # ------------------------------------------------------------------
303 # Signature for LZMA compressed data with valid properties byte 0x5B
304 # ------------------------------------------------------------------
305 0               string  \x5B\x00\x00    LZMA compressed data, properties: 0x5B,
306
307 # These are all the valid dictionary sizes supported by LZMA utils.
308 >1              lelong  !65536  
309 >>1             lelong  !131072 
310 >>>1            lelong  !262144 
311 >>>>1           lelong  !524288 
312 >>>>>1          lelong  !1048576        
313 >>>>>>1         lelong  !2097152        
314 >>>>>>>1        lelong  !4194304        
315 >>>>>>>>1       lelong  !8388608        
316 >>>>>>>>>1      lelong  !16777216       
317 >>>>>>>>>>1     lelong  !33554432       invalid
318 >1              lelong  x               dictionary size: %d bytes,
319
320 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
321 # This could technically be valid, but is unlikely.
322 >5              lequad  !-1
323 >>5             lequad  <32             invalid
324 >>5             lequad  >0x40000000     invalid
325
326 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
327 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
328 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
329 >1              lelong  65536
330 >>5             lequad  65536           invalid
331 >1              lelong  131072
332 >>5             lequad  131072          invalid
333 >1              lelong  262144
334 >>5             lequad  262144          invalid
335 >1              lelong  524288
336 >>5             lequad  524288          invalid
337 >1              lelong  1048576
338 >>5             lequad  1048576         invalid
339 >1              lelong  2097152
340 >>5             lequad  2097152         invalid
341 >1              lelong  4194304
342 >>5             lequad  4194304         invalid
343 >1              lelong  8388608
344 >>5             lequad  8388608         invalid
345 >1              lelong  16777216
346 >>5             lequad  16777216        invalid
347 >1              lelong  33554432
348 >>5             lequad  33554432        invalid
349 >5              lequad  x               uncompressed size: %lld bytes
350
351
352 # ------------------------------------------------------------------
353 # Signature for LZMA compressed data with valid properties byte 0x5C
354 # ------------------------------------------------------------------
355 0               string  \x5C\x00\x00    LZMA compressed data, properties: 0x5C,
356
357 # These are all the valid dictionary sizes supported by LZMA utils.
358 >1              lelong  !65536  
359 >>1             lelong  !131072 
360 >>>1            lelong  !262144 
361 >>>>1           lelong  !524288 
362 >>>>>1          lelong  !1048576        
363 >>>>>>1         lelong  !2097152        
364 >>>>>>>1        lelong  !4194304        
365 >>>>>>>>1       lelong  !8388608        
366 >>>>>>>>>1      lelong  !16777216       
367 >>>>>>>>>>1     lelong  !33554432       invalid
368 >1              lelong  x               dictionary size: %d bytes,
369
370 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
371 # This could technically be valid, but is unlikely.
372 >5              lequad  !-1
373 >>5             lequad  <32             invalid
374 >>5             lequad  >0x40000000     invalid
375
376 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
377 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
378 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
379 >1              lelong  65536
380 >>5             lequad  65536           invalid
381 >1              lelong  131072
382 >>5             lequad  131072          invalid
383 >1              lelong  262144
384 >>5             lequad  262144          invalid
385 >1              lelong  524288
386 >>5             lequad  524288          invalid
387 >1              lelong  1048576
388 >>5             lequad  1048576         invalid
389 >1              lelong  2097152
390 >>5             lequad  2097152         invalid
391 >1              lelong  4194304
392 >>5             lequad  4194304         invalid
393 >1              lelong  8388608
394 >>5             lequad  8388608         invalid
395 >1              lelong  16777216
396 >>5             lequad  16777216        invalid
397 >1              lelong  33554432
398 >>5             lequad  33554432        invalid
399 >5              lequad  x               uncompressed size: %lld bytes
400
401
402 # ------------------------------------------------------------------
403 # Signature for LZMA compressed data with valid properties byte 0x5D
404 # ------------------------------------------------------------------
405 0               string  \x5D\x00\x00    LZMA compressed data, properties: 0x5D,
406
407 # These are all the valid dictionary sizes supported by LZMA utils.
408 >1              lelong  !65536  
409 >>1             lelong  !131072 
410 >>>1            lelong  !262144 
411 >>>>1           lelong  !524288 
412 >>>>>1          lelong  !1048576        
413 >>>>>>1         lelong  !2097152        
414 >>>>>>>1        lelong  !4194304        
415 >>>>>>>>1       lelong  !8388608        
416 >>>>>>>>>1      lelong  !16777216       
417 >>>>>>>>>>1     lelong  !33554432       invalid
418 >1              lelong  x               dictionary size: %d bytes,
419
420 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
421 # This could technically be valid, but is unlikely.
422 >5              lequad  !-1
423 >>5             lequad  <32             invalid
424 >>5             lequad  >0x40000000     invalid
425
426 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
427 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
428 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
429 >1              lelong  65536
430 >>5             lequad  65536           invalid
431 >1              lelong  131072
432 >>5             lequad  131072          invalid
433 >1              lelong  262144
434 >>5             lequad  262144          invalid
435 >1              lelong  524288
436 >>5             lequad  524288          invalid
437 >1              lelong  1048576
438 >>5             lequad  1048576         invalid
439 >1              lelong  2097152
440 >>5             lequad  2097152         invalid
441 >1              lelong  4194304
442 >>5             lequad  4194304         invalid
443 >1              lelong  8388608
444 >>5             lequad  8388608         invalid
445 >1              lelong  16777216
446 >>5             lequad  16777216        invalid
447 >1              lelong  33554432
448 >>5             lequad  33554432        invalid
449 >5              lequad  x               uncompressed size: %lld bytes
450
451
452 # ------------------------------------------------------------------
453 # Signature for LZMA compressed data with valid properties byte 0x5E
454 # ------------------------------------------------------------------
455 0               string  \x5E\x00\x00    LZMA compressed data, properties: 0x5E,
456
457 # These are all the valid dictionary sizes supported by LZMA utils.
458 >1              lelong  !65536  
459 >>1             lelong  !131072 
460 >>>1            lelong  !262144 
461 >>>>1           lelong  !524288 
462 >>>>>1          lelong  !1048576        
463 >>>>>>1         lelong  !2097152        
464 >>>>>>>1        lelong  !4194304        
465 >>>>>>>>1       lelong  !8388608        
466 >>>>>>>>>1      lelong  !16777216       
467 >>>>>>>>>>1     lelong  !33554432       invalid
468 >1              lelong  x               dictionary size: %d bytes,
469
470 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
471 # This could technically be valid, but is unlikely.
472 >5              lequad  !-1
473 >>5             lequad  <32             invalid
474 >>5             lequad  >0x40000000     invalid
475
476 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
477 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
478 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
479 >1              lelong  65536
480 >>5             lequad  65536           invalid
481 >1              lelong  131072
482 >>5             lequad  131072          invalid
483 >1              lelong  262144
484 >>5             lequad  262144          invalid
485 >1              lelong  524288
486 >>5             lequad  524288          invalid
487 >1              lelong  1048576
488 >>5             lequad  1048576         invalid
489 >1              lelong  2097152
490 >>5             lequad  2097152         invalid
491 >1              lelong  4194304
492 >>5             lequad  4194304         invalid
493 >1              lelong  8388608
494 >>5             lequad  8388608         invalid
495 >1              lelong  16777216
496 >>5             lequad  16777216        invalid
497 >1              lelong  33554432
498 >>5             lequad  33554432        invalid
499 >5              lequad  x               uncompressed size: %lld bytes
500
501
502 # ------------------------------------------------------------------
503 # Signature for LZMA compressed data with valid properties byte 0x63
504 # ------------------------------------------------------------------
505 0               string  \x63\x00\x00    LZMA compressed data, properties: 0x63,
506
507 # These are all the valid dictionary sizes supported by LZMA utils.
508 >1              lelong  !65536  
509 >>1             lelong  !131072 
510 >>>1            lelong  !262144 
511 >>>>1           lelong  !524288 
512 >>>>>1          lelong  !1048576        
513 >>>>>>1         lelong  !2097152        
514 >>>>>>>1        lelong  !4194304        
515 >>>>>>>>1       lelong  !8388608        
516 >>>>>>>>>1      lelong  !16777216       
517 >>>>>>>>>>1     lelong  !33554432       invalid
518 >1              lelong  x               dictionary size: %d bytes,
519
520 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
521 # This could technically be valid, but is unlikely.
522 >5              lequad  !-1
523 >>5             lequad  <32             invalid
524 >>5             lequad  >0x40000000     invalid
525
526 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
527 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
528 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
529 >1              lelong  65536
530 >>5             lequad  65536           invalid
531 >1              lelong  131072
532 >>5             lequad  131072          invalid
533 >1              lelong  262144
534 >>5             lequad  262144          invalid
535 >1              lelong  524288
536 >>5             lequad  524288          invalid
537 >1              lelong  1048576
538 >>5             lequad  1048576         invalid
539 >1              lelong  2097152
540 >>5             lequad  2097152         invalid
541 >1              lelong  4194304
542 >>5             lequad  4194304         invalid
543 >1              lelong  8388608
544 >>5             lequad  8388608         invalid
545 >1              lelong  16777216
546 >>5             lequad  16777216        invalid
547 >1              lelong  33554432
548 >>5             lequad  33554432        invalid
549 >5              lequad  x               uncompressed size: %lld bytes
550
551
552 # ------------------------------------------------------------------
553 # Signature for LZMA compressed data with valid properties byte 0x64
554 # ------------------------------------------------------------------
555 0               string  \x64\x00\x00    LZMA compressed data, properties: 0x64,
556
557 # These are all the valid dictionary sizes supported by LZMA utils.
558 >1              lelong  !65536  
559 >>1             lelong  !131072 
560 >>>1            lelong  !262144 
561 >>>>1           lelong  !524288 
562 >>>>>1          lelong  !1048576        
563 >>>>>>1         lelong  !2097152        
564 >>>>>>>1        lelong  !4194304        
565 >>>>>>>>1       lelong  !8388608        
566 >>>>>>>>>1      lelong  !16777216       
567 >>>>>>>>>>1     lelong  !33554432       invalid
568 >1              lelong  x               dictionary size: %d bytes,
569
570 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
571 # This could technically be valid, but is unlikely.
572 >5              lequad  !-1
573 >>5             lequad  <32             invalid
574 >>5             lequad  >0x40000000     invalid
575
576 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
577 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
578 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
579 >1              lelong  65536
580 >>5             lequad  65536           invalid
581 >1              lelong  131072
582 >>5             lequad  131072          invalid
583 >1              lelong  262144
584 >>5             lequad  262144          invalid
585 >1              lelong  524288
586 >>5             lequad  524288          invalid
587 >1              lelong  1048576
588 >>5             lequad  1048576         invalid
589 >1              lelong  2097152
590 >>5             lequad  2097152         invalid
591 >1              lelong  4194304
592 >>5             lequad  4194304         invalid
593 >1              lelong  8388608
594 >>5             lequad  8388608         invalid
595 >1              lelong  16777216
596 >>5             lequad  16777216        invalid
597 >1              lelong  33554432
598 >>5             lequad  33554432        invalid
599 >5              lequad  x               uncompressed size: %lld bytes
600
601
602 # ------------------------------------------------------------------
603 # Signature for LZMA compressed data with valid properties byte 0x65
604 # ------------------------------------------------------------------
605 0               string  \x65\x00\x00    LZMA compressed data, properties: 0x65,
606
607 # These are all the valid dictionary sizes supported by LZMA utils.
608 >1              lelong  !65536  
609 >>1             lelong  !131072 
610 >>>1            lelong  !262144 
611 >>>>1           lelong  !524288 
612 >>>>>1          lelong  !1048576        
613 >>>>>>1         lelong  !2097152        
614 >>>>>>>1        lelong  !4194304        
615 >>>>>>>>1       lelong  !8388608        
616 >>>>>>>>>1      lelong  !16777216       
617 >>>>>>>>>>1     lelong  !33554432       invalid
618 >1              lelong  x               dictionary size: %d bytes,
619
620 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
621 # This could technically be valid, but is unlikely.
622 >5              lequad  !-1
623 >>5             lequad  <32             invalid
624 >>5             lequad  >0x40000000     invalid
625
626 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
627 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
628 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
629 >1              lelong  65536
630 >>5             lequad  65536           invalid
631 >1              lelong  131072
632 >>5             lequad  131072          invalid
633 >1              lelong  262144
634 >>5             lequad  262144          invalid
635 >1              lelong  524288
636 >>5             lequad  524288          invalid
637 >1              lelong  1048576
638 >>5             lequad  1048576         invalid
639 >1              lelong  2097152
640 >>5             lequad  2097152         invalid
641 >1              lelong  4194304
642 >>5             lequad  4194304         invalid
643 >1              lelong  8388608
644 >>5             lequad  8388608         invalid
645 >1              lelong  16777216
646 >>5             lequad  16777216        invalid
647 >1              lelong  33554432
648 >>5             lequad  33554432        invalid
649 >5              lequad  x               uncompressed size: %lld bytes
650
651
652 # ------------------------------------------------------------------
653 # Signature for LZMA compressed data with valid properties byte 0x66
654 # ------------------------------------------------------------------
655 0               string  \x66\x00\x00    LZMA compressed data, properties: 0x66,
656
657 # These are all the valid dictionary sizes supported by LZMA utils.
658 >1              lelong  !65536  
659 >>1             lelong  !131072 
660 >>>1            lelong  !262144 
661 >>>>1           lelong  !524288 
662 >>>>>1          lelong  !1048576        
663 >>>>>>1         lelong  !2097152        
664 >>>>>>>1        lelong  !4194304        
665 >>>>>>>>1       lelong  !8388608        
666 >>>>>>>>>1      lelong  !16777216       
667 >>>>>>>>>>1     lelong  !33554432       invalid
668 >1              lelong  x               dictionary size: %d bytes,
669
670 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
671 # This could technically be valid, but is unlikely.
672 >5              lequad  !-1
673 >>5             lequad  <32             invalid
674 >>5             lequad  >0x40000000     invalid
675
676 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
677 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
678 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
679 >1              lelong  65536
680 >>5             lequad  65536           invalid
681 >1              lelong  131072
682 >>5             lequad  131072          invalid
683 >1              lelong  262144
684 >>5             lequad  262144          invalid
685 >1              lelong  524288
686 >>5             lequad  524288          invalid
687 >1              lelong  1048576
688 >>5             lequad  1048576         invalid
689 >1              lelong  2097152
690 >>5             lequad  2097152         invalid
691 >1              lelong  4194304
692 >>5             lequad  4194304         invalid
693 >1              lelong  8388608
694 >>5             lequad  8388608         invalid
695 >1              lelong  16777216
696 >>5             lequad  16777216        invalid
697 >1              lelong  33554432
698 >>5             lequad  33554432        invalid
699 >5              lequad  x               uncompressed size: %lld bytes
700
701
702 # ------------------------------------------------------------------
703 # Signature for LZMA compressed data with valid properties byte 0x6C
704 # ------------------------------------------------------------------
705 0               string  \x6C\x00\x00    LZMA compressed data, properties: 0x6C,
706
707 # These are all the valid dictionary sizes supported by LZMA utils.
708 >1              lelong  !65536  
709 >>1             lelong  !131072 
710 >>>1            lelong  !262144 
711 >>>>1           lelong  !524288 
712 >>>>>1          lelong  !1048576        
713 >>>>>>1         lelong  !2097152        
714 >>>>>>>1        lelong  !4194304        
715 >>>>>>>>1       lelong  !8388608        
716 >>>>>>>>>1      lelong  !16777216       
717 >>>>>>>>>>1     lelong  !33554432       invalid
718 >1              lelong  x               dictionary size: %d bytes,
719
720 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
721 # This could technically be valid, but is unlikely.
722 >5              lequad  !-1
723 >>5             lequad  <32             invalid
724 >>5             lequad  >0x40000000     invalid
725
726 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
727 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
728 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
729 >1              lelong  65536
730 >>5             lequad  65536           invalid
731 >1              lelong  131072
732 >>5             lequad  131072          invalid
733 >1              lelong  262144
734 >>5             lequad  262144          invalid
735 >1              lelong  524288
736 >>5             lequad  524288          invalid
737 >1              lelong  1048576
738 >>5             lequad  1048576         invalid
739 >1              lelong  2097152
740 >>5             lequad  2097152         invalid
741 >1              lelong  4194304
742 >>5             lequad  4194304         invalid
743 >1              lelong  8388608
744 >>5             lequad  8388608         invalid
745 >1              lelong  16777216
746 >>5             lequad  16777216        invalid
747 >1              lelong  33554432
748 >>5             lequad  33554432        invalid
749 >5              lequad  x               uncompressed size: %lld bytes
750
751
752 # ------------------------------------------------------------------
753 # Signature for LZMA compressed data with valid properties byte 0x6D
754 # ------------------------------------------------------------------
755 0               string  \x6D\x00\x00    LZMA compressed data, properties: 0x6D,
756
757 # These are all the valid dictionary sizes supported by LZMA utils.
758 >1              lelong  !65536  
759 >>1             lelong  !131072 
760 >>>1            lelong  !262144 
761 >>>>1           lelong  !524288 
762 >>>>>1          lelong  !1048576        
763 >>>>>>1         lelong  !2097152        
764 >>>>>>>1        lelong  !4194304        
765 >>>>>>>>1       lelong  !8388608        
766 >>>>>>>>>1      lelong  !16777216       
767 >>>>>>>>>>1     lelong  !33554432       invalid
768 >1              lelong  x               dictionary size: %d bytes,
769
770 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
771 # This could technically be valid, but is unlikely.
772 >5              lequad  !-1
773 >>5             lequad  <32             invalid
774 >>5             lequad  >0x40000000     invalid
775
776 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
777 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
778 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
779 >1              lelong  65536
780 >>5             lequad  65536           invalid
781 >1              lelong  131072
782 >>5             lequad  131072          invalid
783 >1              lelong  262144
784 >>5             lequad  262144          invalid
785 >1              lelong  524288
786 >>5             lequad  524288          invalid
787 >1              lelong  1048576
788 >>5             lequad  1048576         invalid
789 >1              lelong  2097152
790 >>5             lequad  2097152         invalid
791 >1              lelong  4194304
792 >>5             lequad  4194304         invalid
793 >1              lelong  8388608
794 >>5             lequad  8388608         invalid
795 >1              lelong  16777216
796 >>5             lequad  16777216        invalid
797 >1              lelong  33554432
798 >>5             lequad  33554432        invalid
799 >5              lequad  x               uncompressed size: %lld bytes
800
801
802 # ------------------------------------------------------------------
803 # Signature for LZMA compressed data with valid properties byte 0x6E
804 # ------------------------------------------------------------------
805 0               string  \x6E\x00\x00    LZMA compressed data, properties: 0x6E,
806
807 # These are all the valid dictionary sizes supported by LZMA utils.
808 >1              lelong  !65536  
809 >>1             lelong  !131072 
810 >>>1            lelong  !262144 
811 >>>>1           lelong  !524288 
812 >>>>>1          lelong  !1048576        
813 >>>>>>1         lelong  !2097152        
814 >>>>>>>1        lelong  !4194304        
815 >>>>>>>>1       lelong  !8388608        
816 >>>>>>>>>1      lelong  !16777216       
817 >>>>>>>>>>1     lelong  !33554432       invalid
818 >1              lelong  x               dictionary size: %d bytes,
819
820 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
821 # This could technically be valid, but is unlikely.
822 >5              lequad  !-1
823 >>5             lequad  <32             invalid
824 >>5             lequad  >0x40000000     invalid
825
826 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
827 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
828 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
829 >1              lelong  65536
830 >>5             lequad  65536           invalid
831 >1              lelong  131072
832 >>5             lequad  131072          invalid
833 >1              lelong  262144
834 >>5             lequad  262144          invalid
835 >1              lelong  524288
836 >>5             lequad  524288          invalid
837 >1              lelong  1048576
838 >>5             lequad  1048576         invalid
839 >1              lelong  2097152
840 >>5             lequad  2097152         invalid
841 >1              lelong  4194304
842 >>5             lequad  4194304         invalid
843 >1              lelong  8388608
844 >>5             lequad  8388608         invalid
845 >1              lelong  16777216
846 >>5             lequad  16777216        invalid
847 >1              lelong  33554432
848 >>5             lequad  33554432        invalid
849 >5              lequad  x               uncompressed size: %lld bytes
850
851
852 # ------------------------------------------------------------------
853 # Signature for LZMA compressed data with valid properties byte 0x75
854 # ------------------------------------------------------------------
855 0               string  \x75\x00\x00    LZMA compressed data, properties: 0x75,
856
857 # These are all the valid dictionary sizes supported by LZMA utils.
858 >1              lelong  !65536  
859 >>1             lelong  !131072 
860 >>>1            lelong  !262144 
861 >>>>1           lelong  !524288 
862 >>>>>1          lelong  !1048576        
863 >>>>>>1         lelong  !2097152        
864 >>>>>>>1        lelong  !4194304        
865 >>>>>>>>1       lelong  !8388608        
866 >>>>>>>>>1      lelong  !16777216       
867 >>>>>>>>>>1     lelong  !33554432       invalid
868 >1              lelong  x               dictionary size: %d bytes,
869
870 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
871 # This could technically be valid, but is unlikely.
872 >5              lequad  !-1
873 >>5             lequad  <32             invalid
874 >>5             lequad  >0x40000000     invalid
875
876 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
877 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
878 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
879 >1              lelong  65536
880 >>5             lequad  65536           invalid
881 >1              lelong  131072
882 >>5             lequad  131072          invalid
883 >1              lelong  262144
884 >>5             lequad  262144          invalid
885 >1              lelong  524288
886 >>5             lequad  524288          invalid
887 >1              lelong  1048576
888 >>5             lequad  1048576         invalid
889 >1              lelong  2097152
890 >>5             lequad  2097152         invalid
891 >1              lelong  4194304
892 >>5             lequad  4194304         invalid
893 >1              lelong  8388608
894 >>5             lequad  8388608         invalid
895 >1              lelong  16777216
896 >>5             lequad  16777216        invalid
897 >1              lelong  33554432
898 >>5             lequad  33554432        invalid
899 >5              lequad  x               uncompressed size: %lld bytes
900
901
902 # ------------------------------------------------------------------
903 # Signature for LZMA compressed data with valid properties byte 0x76
904 # ------------------------------------------------------------------
905 0               string  \x76\x00\x00    LZMA compressed data, properties: 0x76,
906
907 # These are all the valid dictionary sizes supported by LZMA utils.
908 >1              lelong  !65536  
909 >>1             lelong  !131072 
910 >>>1            lelong  !262144 
911 >>>>1           lelong  !524288 
912 >>>>>1          lelong  !1048576        
913 >>>>>>1         lelong  !2097152        
914 >>>>>>>1        lelong  !4194304        
915 >>>>>>>>1       lelong  !8388608        
916 >>>>>>>>>1      lelong  !16777216       
917 >>>>>>>>>>1     lelong  !33554432       invalid
918 >1              lelong  x               dictionary size: %d bytes,
919
920 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
921 # This could technically be valid, but is unlikely.
922 >5              lequad  !-1
923 >>5             lequad  <32             invalid
924 >>5             lequad  >0x40000000     invalid
925
926 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
927 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
928 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
929 >1              lelong  65536
930 >>5             lequad  65536           invalid
931 >1              lelong  131072
932 >>5             lequad  131072          invalid
933 >1              lelong  262144
934 >>5             lequad  262144          invalid
935 >1              lelong  524288
936 >>5             lequad  524288          invalid
937 >1              lelong  1048576
938 >>5             lequad  1048576         invalid
939 >1              lelong  2097152
940 >>5             lequad  2097152         invalid
941 >1              lelong  4194304
942 >>5             lequad  4194304         invalid
943 >1              lelong  8388608
944 >>5             lequad  8388608         invalid
945 >1              lelong  16777216
946 >>5             lequad  16777216        invalid
947 >1              lelong  33554432
948 >>5             lequad  33554432        invalid
949 >5              lequad  x               uncompressed size: %lld bytes
950
951
952 # ------------------------------------------------------------------
953 # Signature for LZMA compressed data with valid properties byte 0x7E
954 # ------------------------------------------------------------------
955 0               string  \x7E\x00\x00    LZMA compressed data, properties: 0x7E,
956
957 # These are all the valid dictionary sizes supported by LZMA utils.
958 >1              lelong  !65536  
959 >>1             lelong  !131072 
960 >>>1            lelong  !262144 
961 >>>>1           lelong  !524288 
962 >>>>>1          lelong  !1048576        
963 >>>>>>1         lelong  !2097152        
964 >>>>>>>1        lelong  !4194304        
965 >>>>>>>>1       lelong  !8388608        
966 >>>>>>>>>1      lelong  !16777216       
967 >>>>>>>>>>1     lelong  !33554432       invalid
968 >1              lelong  x               dictionary size: %d bytes,
969
970 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
971 # This could technically be valid, but is unlikely.
972 >5              lequad  !-1
973 >>5             lequad  <32             invalid
974 >>5             lequad  >0x40000000     invalid
975
976 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
977 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
978 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
979 >1              lelong  65536
980 >>5             lequad  65536           invalid
981 >1              lelong  131072
982 >>5             lequad  131072          invalid
983 >1              lelong  262144
984 >>5             lequad  262144          invalid
985 >1              lelong  524288
986 >>5             lequad  524288          invalid
987 >1              lelong  1048576
988 >>5             lequad  1048576         invalid
989 >1              lelong  2097152
990 >>5             lequad  2097152         invalid
991 >1              lelong  4194304
992 >>5             lequad  4194304         invalid
993 >1              lelong  8388608
994 >>5             lequad  8388608         invalid
995 >1              lelong  16777216
996 >>5             lequad  16777216        invalid
997 >1              lelong  33554432
998 >>5             lequad  33554432        invalid
999 >5              lequad  x               uncompressed size: %lld bytes
1000
1001
1002 # ------------------------------------------------------------------
1003 # Signature for LZMA compressed data with valid properties byte 0x87
1004 # ------------------------------------------------------------------
1005 0               string  \x87\x00\x00    LZMA compressed data, properties: 0x87,
1006
1007 # These are all the valid dictionary sizes supported by LZMA utils.
1008 >1              lelong  !65536  
1009 >>1             lelong  !131072 
1010 >>>1            lelong  !262144 
1011 >>>>1           lelong  !524288 
1012 >>>>>1          lelong  !1048576        
1013 >>>>>>1         lelong  !2097152        
1014 >>>>>>>1        lelong  !4194304        
1015 >>>>>>>>1       lelong  !8388608        
1016 >>>>>>>>>1      lelong  !16777216       
1017 >>>>>>>>>>1     lelong  !33554432       invalid
1018 >1              lelong  x               dictionary size: %d bytes,
1019
1020 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1021 # This could technically be valid, but is unlikely.
1022 >5              lequad  !-1
1023 >>5             lequad  <32             invalid
1024 >>5             lequad  >0x40000000     invalid
1025
1026 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1027 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1028 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1029 >1              lelong  65536
1030 >>5             lequad  65536           invalid
1031 >1              lelong  131072
1032 >>5             lequad  131072          invalid
1033 >1              lelong  262144
1034 >>5             lequad  262144          invalid
1035 >1              lelong  524288
1036 >>5             lequad  524288          invalid
1037 >1              lelong  1048576
1038 >>5             lequad  1048576         invalid
1039 >1              lelong  2097152
1040 >>5             lequad  2097152         invalid
1041 >1              lelong  4194304
1042 >>5             lequad  4194304         invalid
1043 >1              lelong  8388608
1044 >>5             lequad  8388608         invalid
1045 >1              lelong  16777216
1046 >>5             lequad  16777216        invalid
1047 >1              lelong  33554432
1048 >>5             lequad  33554432        invalid
1049 >5              lequad  x               uncompressed size: %lld bytes
1050
1051
1052 # ------------------------------------------------------------------
1053 # Signature for LZMA compressed data with valid properties byte 0x88
1054 # ------------------------------------------------------------------
1055 0               string  \x88\x00\x00    LZMA compressed data, properties: 0x88,
1056
1057 # These are all the valid dictionary sizes supported by LZMA utils.
1058 >1              lelong  !65536  
1059 >>1             lelong  !131072 
1060 >>>1            lelong  !262144 
1061 >>>>1           lelong  !524288 
1062 >>>>>1          lelong  !1048576        
1063 >>>>>>1         lelong  !2097152        
1064 >>>>>>>1        lelong  !4194304        
1065 >>>>>>>>1       lelong  !8388608        
1066 >>>>>>>>>1      lelong  !16777216       
1067 >>>>>>>>>>1     lelong  !33554432       invalid
1068 >1              lelong  x               dictionary size: %d bytes,
1069
1070 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1071 # This could technically be valid, but is unlikely.
1072 >5              lequad  !-1
1073 >>5             lequad  <32             invalid
1074 >>5             lequad  >0x40000000     invalid
1075
1076 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1077 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1078 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1079 >1              lelong  65536
1080 >>5             lequad  65536           invalid
1081 >1              lelong  131072
1082 >>5             lequad  131072          invalid
1083 >1              lelong  262144
1084 >>5             lequad  262144          invalid
1085 >1              lelong  524288
1086 >>5             lequad  524288          invalid
1087 >1              lelong  1048576
1088 >>5             lequad  1048576         invalid
1089 >1              lelong  2097152
1090 >>5             lequad  2097152         invalid
1091 >1              lelong  4194304
1092 >>5             lequad  4194304         invalid
1093 >1              lelong  8388608
1094 >>5             lequad  8388608         invalid
1095 >1              lelong  16777216
1096 >>5             lequad  16777216        invalid
1097 >1              lelong  33554432
1098 >>5             lequad  33554432        invalid
1099 >5              lequad  x               uncompressed size: %lld bytes
1100
1101
1102 # ------------------------------------------------------------------
1103 # Signature for LZMA compressed data with valid properties byte 0x89
1104 # ------------------------------------------------------------------
1105 0               string  \x89\x00\x00    LZMA compressed data, properties: 0x89,
1106
1107 # These are all the valid dictionary sizes supported by LZMA utils.
1108 >1              lelong  !65536  
1109 >>1             lelong  !131072 
1110 >>>1            lelong  !262144 
1111 >>>>1           lelong  !524288 
1112 >>>>>1          lelong  !1048576        
1113 >>>>>>1         lelong  !2097152        
1114 >>>>>>>1        lelong  !4194304        
1115 >>>>>>>>1       lelong  !8388608        
1116 >>>>>>>>>1      lelong  !16777216       
1117 >>>>>>>>>>1     lelong  !33554432       invalid
1118 >1              lelong  x               dictionary size: %d bytes,
1119
1120 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1121 # This could technically be valid, but is unlikely.
1122 >5              lequad  !-1
1123 >>5             lequad  <32             invalid
1124 >>5             lequad  >0x40000000     invalid
1125
1126 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1127 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1128 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1129 >1              lelong  65536
1130 >>5             lequad  65536           invalid
1131 >1              lelong  131072
1132 >>5             lequad  131072          invalid
1133 >1              lelong  262144
1134 >>5             lequad  262144          invalid
1135 >1              lelong  524288
1136 >>5             lequad  524288          invalid
1137 >1              lelong  1048576
1138 >>5             lequad  1048576         invalid
1139 >1              lelong  2097152
1140 >>5             lequad  2097152         invalid
1141 >1              lelong  4194304
1142 >>5             lequad  4194304         invalid
1143 >1              lelong  8388608
1144 >>5             lequad  8388608         invalid
1145 >1              lelong  16777216
1146 >>5             lequad  16777216        invalid
1147 >1              lelong  33554432
1148 >>5             lequad  33554432        invalid
1149 >5              lequad  x               uncompressed size: %lld bytes
1150
1151
1152 # ------------------------------------------------------------------
1153 # Signature for LZMA compressed data with valid properties byte 0x8A
1154 # ------------------------------------------------------------------
1155 0               string  \x8A\x00\x00    LZMA compressed data, properties: 0x8A,
1156
1157 # These are all the valid dictionary sizes supported by LZMA utils.
1158 >1              lelong  !65536  
1159 >>1             lelong  !131072 
1160 >>>1            lelong  !262144 
1161 >>>>1           lelong  !524288 
1162 >>>>>1          lelong  !1048576        
1163 >>>>>>1         lelong  !2097152        
1164 >>>>>>>1        lelong  !4194304        
1165 >>>>>>>>1       lelong  !8388608        
1166 >>>>>>>>>1      lelong  !16777216       
1167 >>>>>>>>>>1     lelong  !33554432       invalid
1168 >1              lelong  x               dictionary size: %d bytes,
1169
1170 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1171 # This could technically be valid, but is unlikely.
1172 >5              lequad  !-1
1173 >>5             lequad  <32             invalid
1174 >>5             lequad  >0x40000000     invalid
1175
1176 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1177 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1178 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1179 >1              lelong  65536
1180 >>5             lequad  65536           invalid
1181 >1              lelong  131072
1182 >>5             lequad  131072          invalid
1183 >1              lelong  262144
1184 >>5             lequad  262144          invalid
1185 >1              lelong  524288
1186 >>5             lequad  524288          invalid
1187 >1              lelong  1048576
1188 >>5             lequad  1048576         invalid
1189 >1              lelong  2097152
1190 >>5             lequad  2097152         invalid
1191 >1              lelong  4194304
1192 >>5             lequad  4194304         invalid
1193 >1              lelong  8388608
1194 >>5             lequad  8388608         invalid
1195 >1              lelong  16777216
1196 >>5             lequad  16777216        invalid
1197 >1              lelong  33554432
1198 >>5             lequad  33554432        invalid
1199 >5              lequad  x               uncompressed size: %lld bytes
1200
1201
1202 # ------------------------------------------------------------------
1203 # Signature for LZMA compressed data with valid properties byte 0x8B
1204 # ------------------------------------------------------------------
1205 0               string  \x8B\x00\x00    LZMA compressed data, properties: 0x8B,
1206
1207 # These are all the valid dictionary sizes supported by LZMA utils.
1208 >1              lelong  !65536  
1209 >>1             lelong  !131072 
1210 >>>1            lelong  !262144 
1211 >>>>1           lelong  !524288 
1212 >>>>>1          lelong  !1048576        
1213 >>>>>>1         lelong  !2097152        
1214 >>>>>>>1        lelong  !4194304        
1215 >>>>>>>>1       lelong  !8388608        
1216 >>>>>>>>>1      lelong  !16777216       
1217 >>>>>>>>>>1     lelong  !33554432       invalid
1218 >1              lelong  x               dictionary size: %d bytes,
1219
1220 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1221 # This could technically be valid, but is unlikely.
1222 >5              lequad  !-1
1223 >>5             lequad  <32             invalid
1224 >>5             lequad  >0x40000000     invalid
1225
1226 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1227 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1228 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1229 >1              lelong  65536
1230 >>5             lequad  65536           invalid
1231 >1              lelong  131072
1232 >>5             lequad  131072          invalid
1233 >1              lelong  262144
1234 >>5             lequad  262144          invalid
1235 >1              lelong  524288
1236 >>5             lequad  524288          invalid
1237 >1              lelong  1048576
1238 >>5             lequad  1048576         invalid
1239 >1              lelong  2097152
1240 >>5             lequad  2097152         invalid
1241 >1              lelong  4194304
1242 >>5             lequad  4194304         invalid
1243 >1              lelong  8388608
1244 >>5             lequad  8388608         invalid
1245 >1              lelong  16777216
1246 >>5             lequad  16777216        invalid
1247 >1              lelong  33554432
1248 >>5             lequad  33554432        invalid
1249 >5              lequad  x               uncompressed size: %lld bytes
1250
1251
1252 # ------------------------------------------------------------------
1253 # Signature for LZMA compressed data with valid properties byte 0x90
1254 # ------------------------------------------------------------------
1255 0               string  \x90\x00\x00    LZMA compressed data, properties: 0x90,
1256
1257 # These are all the valid dictionary sizes supported by LZMA utils.
1258 >1              lelong  !65536  
1259 >>1             lelong  !131072 
1260 >>>1            lelong  !262144 
1261 >>>>1           lelong  !524288 
1262 >>>>>1          lelong  !1048576        
1263 >>>>>>1         lelong  !2097152        
1264 >>>>>>>1        lelong  !4194304        
1265 >>>>>>>>1       lelong  !8388608        
1266 >>>>>>>>>1      lelong  !16777216       
1267 >>>>>>>>>>1     lelong  !33554432       invalid
1268 >1              lelong  x               dictionary size: %d bytes,
1269
1270 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1271 # This could technically be valid, but is unlikely.
1272 >5              lequad  !-1
1273 >>5             lequad  <32             invalid
1274 >>5             lequad  >0x40000000     invalid
1275
1276 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1277 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1278 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1279 >1              lelong  65536
1280 >>5             lequad  65536           invalid
1281 >1              lelong  131072
1282 >>5             lequad  131072          invalid
1283 >1              lelong  262144
1284 >>5             lequad  262144          invalid
1285 >1              lelong  524288
1286 >>5             lequad  524288          invalid
1287 >1              lelong  1048576
1288 >>5             lequad  1048576         invalid
1289 >1              lelong  2097152
1290 >>5             lequad  2097152         invalid
1291 >1              lelong  4194304
1292 >>5             lequad  4194304         invalid
1293 >1              lelong  8388608
1294 >>5             lequad  8388608         invalid
1295 >1              lelong  16777216
1296 >>5             lequad  16777216        invalid
1297 >1              lelong  33554432
1298 >>5             lequad  33554432        invalid
1299 >5              lequad  x               uncompressed size: %lld bytes
1300
1301
1302 # ------------------------------------------------------------------
1303 # Signature for LZMA compressed data with valid properties byte 0x91
1304 # ------------------------------------------------------------------
1305 0               string  \x91\x00\x00    LZMA compressed data, properties: 0x91,
1306
1307 # These are all the valid dictionary sizes supported by LZMA utils.
1308 >1              lelong  !65536  
1309 >>1             lelong  !131072 
1310 >>>1            lelong  !262144 
1311 >>>>1           lelong  !524288 
1312 >>>>>1          lelong  !1048576        
1313 >>>>>>1         lelong  !2097152        
1314 >>>>>>>1        lelong  !4194304        
1315 >>>>>>>>1       lelong  !8388608        
1316 >>>>>>>>>1      lelong  !16777216       
1317 >>>>>>>>>>1     lelong  !33554432       invalid
1318 >1              lelong  x               dictionary size: %d bytes,
1319
1320 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1321 # This could technically be valid, but is unlikely.
1322 >5              lequad  !-1
1323 >>5             lequad  <32             invalid
1324 >>5             lequad  >0x40000000     invalid
1325
1326 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1327 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1328 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1329 >1              lelong  65536
1330 >>5             lequad  65536           invalid
1331 >1              lelong  131072
1332 >>5             lequad  131072          invalid
1333 >1              lelong  262144
1334 >>5             lequad  262144          invalid
1335 >1              lelong  524288
1336 >>5             lequad  524288          invalid
1337 >1              lelong  1048576
1338 >>5             lequad  1048576         invalid
1339 >1              lelong  2097152
1340 >>5             lequad  2097152         invalid
1341 >1              lelong  4194304
1342 >>5             lequad  4194304         invalid
1343 >1              lelong  8388608
1344 >>5             lequad  8388608         invalid
1345 >1              lelong  16777216
1346 >>5             lequad  16777216        invalid
1347 >1              lelong  33554432
1348 >>5             lequad  33554432        invalid
1349 >5              lequad  x               uncompressed size: %lld bytes
1350
1351
1352 # ------------------------------------------------------------------
1353 # Signature for LZMA compressed data with valid properties byte 0x92
1354 # ------------------------------------------------------------------
1355 0               string  \x92\x00\x00    LZMA compressed data, properties: 0x92,
1356
1357 # These are all the valid dictionary sizes supported by LZMA utils.
1358 >1              lelong  !65536  
1359 >>1             lelong  !131072 
1360 >>>1            lelong  !262144 
1361 >>>>1           lelong  !524288 
1362 >>>>>1          lelong  !1048576        
1363 >>>>>>1         lelong  !2097152        
1364 >>>>>>>1        lelong  !4194304        
1365 >>>>>>>>1       lelong  !8388608        
1366 >>>>>>>>>1      lelong  !16777216       
1367 >>>>>>>>>>1     lelong  !33554432       invalid
1368 >1              lelong  x               dictionary size: %d bytes,
1369
1370 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1371 # This could technically be valid, but is unlikely.
1372 >5              lequad  !-1
1373 >>5             lequad  <32             invalid
1374 >>5             lequad  >0x40000000     invalid
1375
1376 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1377 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1378 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1379 >1              lelong  65536
1380 >>5             lequad  65536           invalid
1381 >1              lelong  131072
1382 >>5             lequad  131072          invalid
1383 >1              lelong  262144
1384 >>5             lequad  262144          invalid
1385 >1              lelong  524288
1386 >>5             lequad  524288          invalid
1387 >1              lelong  1048576
1388 >>5             lequad  1048576         invalid
1389 >1              lelong  2097152
1390 >>5             lequad  2097152         invalid
1391 >1              lelong  4194304
1392 >>5             lequad  4194304         invalid
1393 >1              lelong  8388608
1394 >>5             lequad  8388608         invalid
1395 >1              lelong  16777216
1396 >>5             lequad  16777216        invalid
1397 >1              lelong  33554432
1398 >>5             lequad  33554432        invalid
1399 >5              lequad  x               uncompressed size: %lld bytes
1400
1401
1402 # ------------------------------------------------------------------
1403 # Signature for LZMA compressed data with valid properties byte 0x93
1404 # ------------------------------------------------------------------
1405 0               string  \x93\x00\x00    LZMA compressed data, properties: 0x93,
1406
1407 # These are all the valid dictionary sizes supported by LZMA utils.
1408 >1              lelong  !65536  
1409 >>1             lelong  !131072 
1410 >>>1            lelong  !262144 
1411 >>>>1           lelong  !524288 
1412 >>>>>1          lelong  !1048576        
1413 >>>>>>1         lelong  !2097152        
1414 >>>>>>>1        lelong  !4194304        
1415 >>>>>>>>1       lelong  !8388608        
1416 >>>>>>>>>1      lelong  !16777216       
1417 >>>>>>>>>>1     lelong  !33554432       invalid
1418 >1              lelong  x               dictionary size: %d bytes,
1419
1420 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1421 # This could technically be valid, but is unlikely.
1422 >5              lequad  !-1
1423 >>5             lequad  <32             invalid
1424 >>5             lequad  >0x40000000     invalid
1425
1426 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1427 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1428 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1429 >1              lelong  65536
1430 >>5             lequad  65536           invalid
1431 >1              lelong  131072
1432 >>5             lequad  131072          invalid
1433 >1              lelong  262144
1434 >>5             lequad  262144          invalid
1435 >1              lelong  524288
1436 >>5             lequad  524288          invalid
1437 >1              lelong  1048576
1438 >>5             lequad  1048576         invalid
1439 >1              lelong  2097152
1440 >>5             lequad  2097152         invalid
1441 >1              lelong  4194304
1442 >>5             lequad  4194304         invalid
1443 >1              lelong  8388608
1444 >>5             lequad  8388608         invalid
1445 >1              lelong  16777216
1446 >>5             lequad  16777216        invalid
1447 >1              lelong  33554432
1448 >>5             lequad  33554432        invalid
1449 >5              lequad  x               uncompressed size: %lld bytes
1450
1451
1452 # ------------------------------------------------------------------
1453 # Signature for LZMA compressed data with valid properties byte 0x99
1454 # ------------------------------------------------------------------
1455 0               string  \x99\x00\x00    LZMA compressed data, properties: 0x99,
1456
1457 # These are all the valid dictionary sizes supported by LZMA utils.
1458 >1              lelong  !65536  
1459 >>1             lelong  !131072 
1460 >>>1            lelong  !262144 
1461 >>>>1           lelong  !524288 
1462 >>>>>1          lelong  !1048576        
1463 >>>>>>1         lelong  !2097152        
1464 >>>>>>>1        lelong  !4194304        
1465 >>>>>>>>1       lelong  !8388608        
1466 >>>>>>>>>1      lelong  !16777216       
1467 >>>>>>>>>>1     lelong  !33554432       invalid
1468 >1              lelong  x               dictionary size: %d bytes,
1469
1470 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1471 # This could technically be valid, but is unlikely.
1472 >5              lequad  !-1
1473 >>5             lequad  <32             invalid
1474 >>5             lequad  >0x40000000     invalid
1475
1476 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1477 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1478 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1479 >1              lelong  65536
1480 >>5             lequad  65536           invalid
1481 >1              lelong  131072
1482 >>5             lequad  131072          invalid
1483 >1              lelong  262144
1484 >>5             lequad  262144          invalid
1485 >1              lelong  524288
1486 >>5             lequad  524288          invalid
1487 >1              lelong  1048576
1488 >>5             lequad  1048576         invalid
1489 >1              lelong  2097152
1490 >>5             lequad  2097152         invalid
1491 >1              lelong  4194304
1492 >>5             lequad  4194304         invalid
1493 >1              lelong  8388608
1494 >>5             lequad  8388608         invalid
1495 >1              lelong  16777216
1496 >>5             lequad  16777216        invalid
1497 >1              lelong  33554432
1498 >>5             lequad  33554432        invalid
1499 >5              lequad  x               uncompressed size: %lld bytes
1500
1501
1502 # ------------------------------------------------------------------
1503 # Signature for LZMA compressed data with valid properties byte 0x9A
1504 # ------------------------------------------------------------------
1505 0               string  \x9A\x00\x00    LZMA compressed data, properties: 0x9A,
1506
1507 # These are all the valid dictionary sizes supported by LZMA utils.
1508 >1              lelong  !65536  
1509 >>1             lelong  !131072 
1510 >>>1            lelong  !262144 
1511 >>>>1           lelong  !524288 
1512 >>>>>1          lelong  !1048576        
1513 >>>>>>1         lelong  !2097152        
1514 >>>>>>>1        lelong  !4194304        
1515 >>>>>>>>1       lelong  !8388608        
1516 >>>>>>>>>1      lelong  !16777216       
1517 >>>>>>>>>>1     lelong  !33554432       invalid
1518 >1              lelong  x               dictionary size: %d bytes,
1519
1520 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1521 # This could technically be valid, but is unlikely.
1522 >5              lequad  !-1
1523 >>5             lequad  <32             invalid
1524 >>5             lequad  >0x40000000     invalid
1525
1526 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1527 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1528 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1529 >1              lelong  65536
1530 >>5             lequad  65536           invalid
1531 >1              lelong  131072
1532 >>5             lequad  131072          invalid
1533 >1              lelong  262144
1534 >>5             lequad  262144          invalid
1535 >1              lelong  524288
1536 >>5             lequad  524288          invalid
1537 >1              lelong  1048576
1538 >>5             lequad  1048576         invalid
1539 >1              lelong  2097152
1540 >>5             lequad  2097152         invalid
1541 >1              lelong  4194304
1542 >>5             lequad  4194304         invalid
1543 >1              lelong  8388608
1544 >>5             lequad  8388608         invalid
1545 >1              lelong  16777216
1546 >>5             lequad  16777216        invalid
1547 >1              lelong  33554432
1548 >>5             lequad  33554432        invalid
1549 >5              lequad  x               uncompressed size: %lld bytes
1550
1551
1552 # ------------------------------------------------------------------
1553 # Signature for LZMA compressed data with valid properties byte 0x9B
1554 # ------------------------------------------------------------------
1555 0               string  \x9B\x00\x00    LZMA compressed data, properties: 0x9B,
1556
1557 # These are all the valid dictionary sizes supported by LZMA utils.
1558 >1              lelong  !65536  
1559 >>1             lelong  !131072 
1560 >>>1            lelong  !262144 
1561 >>>>1           lelong  !524288 
1562 >>>>>1          lelong  !1048576        
1563 >>>>>>1         lelong  !2097152        
1564 >>>>>>>1        lelong  !4194304        
1565 >>>>>>>>1       lelong  !8388608        
1566 >>>>>>>>>1      lelong  !16777216       
1567 >>>>>>>>>>1     lelong  !33554432       invalid
1568 >1              lelong  x               dictionary size: %d bytes,
1569
1570 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1571 # This could technically be valid, but is unlikely.
1572 >5              lequad  !-1
1573 >>5             lequad  <32             invalid
1574 >>5             lequad  >0x40000000     invalid
1575
1576 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1577 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1578 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1579 >1              lelong  65536
1580 >>5             lequad  65536           invalid
1581 >1              lelong  131072
1582 >>5             lequad  131072          invalid
1583 >1              lelong  262144
1584 >>5             lequad  262144          invalid
1585 >1              lelong  524288
1586 >>5             lequad  524288          invalid
1587 >1              lelong  1048576
1588 >>5             lequad  1048576         invalid
1589 >1              lelong  2097152
1590 >>5             lequad  2097152         invalid
1591 >1              lelong  4194304
1592 >>5             lequad  4194304         invalid
1593 >1              lelong  8388608
1594 >>5             lequad  8388608         invalid
1595 >1              lelong  16777216
1596 >>5             lequad  16777216        invalid
1597 >1              lelong  33554432
1598 >>5             lequad  33554432        invalid
1599 >5              lequad  x               uncompressed size: %lld bytes
1600
1601
1602 # ------------------------------------------------------------------
1603 # Signature for LZMA compressed data with valid properties byte 0xA2
1604 # ------------------------------------------------------------------
1605 0               string  \xA2\x00\x00    LZMA compressed data, properties: 0xA2,
1606
1607 # These are all the valid dictionary sizes supported by LZMA utils.
1608 >1              lelong  !65536  
1609 >>1             lelong  !131072 
1610 >>>1            lelong  !262144 
1611 >>>>1           lelong  !524288 
1612 >>>>>1          lelong  !1048576        
1613 >>>>>>1         lelong  !2097152        
1614 >>>>>>>1        lelong  !4194304        
1615 >>>>>>>>1       lelong  !8388608        
1616 >>>>>>>>>1      lelong  !16777216       
1617 >>>>>>>>>>1     lelong  !33554432       invalid
1618 >1              lelong  x               dictionary size: %d bytes,
1619
1620 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1621 # This could technically be valid, but is unlikely.
1622 >5              lequad  !-1
1623 >>5             lequad  <32             invalid
1624 >>5             lequad  >0x40000000     invalid
1625
1626 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1627 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1628 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1629 >1              lelong  65536
1630 >>5             lequad  65536           invalid
1631 >1              lelong  131072
1632 >>5             lequad  131072          invalid
1633 >1              lelong  262144
1634 >>5             lequad  262144          invalid
1635 >1              lelong  524288
1636 >>5             lequad  524288          invalid
1637 >1              lelong  1048576
1638 >>5             lequad  1048576         invalid
1639 >1              lelong  2097152
1640 >>5             lequad  2097152         invalid
1641 >1              lelong  4194304
1642 >>5             lequad  4194304         invalid
1643 >1              lelong  8388608
1644 >>5             lequad  8388608         invalid
1645 >1              lelong  16777216
1646 >>5             lequad  16777216        invalid
1647 >1              lelong  33554432
1648 >>5             lequad  33554432        invalid
1649 >5              lequad  x               uncompressed size: %lld bytes
1650
1651
1652 # ------------------------------------------------------------------
1653 # Signature for LZMA compressed data with valid properties byte 0xA3
1654 # ------------------------------------------------------------------
1655 0               string  \xA3\x00\x00    LZMA compressed data, properties: 0xA3,
1656
1657 # These are all the valid dictionary sizes supported by LZMA utils.
1658 >1              lelong  !65536  
1659 >>1             lelong  !131072 
1660 >>>1            lelong  !262144 
1661 >>>>1           lelong  !524288 
1662 >>>>>1          lelong  !1048576        
1663 >>>>>>1         lelong  !2097152        
1664 >>>>>>>1        lelong  !4194304        
1665 >>>>>>>>1       lelong  !8388608        
1666 >>>>>>>>>1      lelong  !16777216       
1667 >>>>>>>>>>1     lelong  !33554432       invalid
1668 >1              lelong  x               dictionary size: %d bytes,
1669
1670 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1671 # This could technically be valid, but is unlikely.
1672 >5              lequad  !-1
1673 >>5             lequad  <32             invalid
1674 >>5             lequad  >0x40000000     invalid
1675
1676 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1677 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1678 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1679 >1              lelong  65536
1680 >>5             lequad  65536           invalid
1681 >1              lelong  131072
1682 >>5             lequad  131072          invalid
1683 >1              lelong  262144
1684 >>5             lequad  262144          invalid
1685 >1              lelong  524288
1686 >>5             lequad  524288          invalid
1687 >1              lelong  1048576
1688 >>5             lequad  1048576         invalid
1689 >1              lelong  2097152
1690 >>5             lequad  2097152         invalid
1691 >1              lelong  4194304
1692 >>5             lequad  4194304         invalid
1693 >1              lelong  8388608
1694 >>5             lequad  8388608         invalid
1695 >1              lelong  16777216
1696 >>5             lequad  16777216        invalid
1697 >1              lelong  33554432
1698 >>5             lequad  33554432        invalid
1699 >5              lequad  x               uncompressed size: %lld bytes
1700
1701
1702 # ------------------------------------------------------------------
1703 # Signature for LZMA compressed data with valid properties byte 0xAB
1704 # ------------------------------------------------------------------
1705 0               string  \xAB\x00\x00    LZMA compressed data, properties: 0xAB,
1706
1707 # These are all the valid dictionary sizes supported by LZMA utils.
1708 >1              lelong  !65536  
1709 >>1             lelong  !131072 
1710 >>>1            lelong  !262144 
1711 >>>>1           lelong  !524288 
1712 >>>>>1          lelong  !1048576        
1713 >>>>>>1         lelong  !2097152        
1714 >>>>>>>1        lelong  !4194304        
1715 >>>>>>>>1       lelong  !8388608        
1716 >>>>>>>>>1      lelong  !16777216       
1717 >>>>>>>>>>1     lelong  !33554432       invalid
1718 >1              lelong  x               dictionary size: %d bytes,
1719
1720 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1721 # This could technically be valid, but is unlikely.
1722 >5              lequad  !-1
1723 >>5             lequad  <32             invalid
1724 >>5             lequad  >0x40000000     invalid
1725
1726 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1727 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1728 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1729 >1              lelong  65536
1730 >>5             lequad  65536           invalid
1731 >1              lelong  131072
1732 >>5             lequad  131072          invalid
1733 >1              lelong  262144
1734 >>5             lequad  262144          invalid
1735 >1              lelong  524288
1736 >>5             lequad  524288          invalid
1737 >1              lelong  1048576
1738 >>5             lequad  1048576         invalid
1739 >1              lelong  2097152
1740 >>5             lequad  2097152         invalid
1741 >1              lelong  4194304
1742 >>5             lequad  4194304         invalid
1743 >1              lelong  8388608
1744 >>5             lequad  8388608         invalid
1745 >1              lelong  16777216
1746 >>5             lequad  16777216        invalid
1747 >1              lelong  33554432
1748 >>5             lequad  33554432        invalid
1749 >5              lequad  x               uncompressed size: %lld bytes
1750
1751
1752 # ------------------------------------------------------------------
1753 # Signature for LZMA compressed data with valid properties byte 0xB4
1754 # ------------------------------------------------------------------
1755 0               string  \xB4\x00\x00    LZMA compressed data, properties: 0xB4,
1756
1757 # These are all the valid dictionary sizes supported by LZMA utils.
1758 >1              lelong  !65536  
1759 >>1             lelong  !131072 
1760 >>>1            lelong  !262144 
1761 >>>>1           lelong  !524288 
1762 >>>>>1          lelong  !1048576        
1763 >>>>>>1         lelong  !2097152        
1764 >>>>>>>1        lelong  !4194304        
1765 >>>>>>>>1       lelong  !8388608        
1766 >>>>>>>>>1      lelong  !16777216       
1767 >>>>>>>>>>1     lelong  !33554432       invalid
1768 >1              lelong  x               dictionary size: %d bytes,
1769
1770 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1771 # This could technically be valid, but is unlikely.
1772 >5              lequad  !-1
1773 >>5             lequad  <32             invalid
1774 >>5             lequad  >0x40000000     invalid
1775
1776 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1777 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1778 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1779 >1              lelong  65536
1780 >>5             lequad  65536           invalid
1781 >1              lelong  131072
1782 >>5             lequad  131072          invalid
1783 >1              lelong  262144
1784 >>5             lequad  262144          invalid
1785 >1              lelong  524288
1786 >>5             lequad  524288          invalid
1787 >1              lelong  1048576
1788 >>5             lequad  1048576         invalid
1789 >1              lelong  2097152
1790 >>5             lequad  2097152         invalid
1791 >1              lelong  4194304
1792 >>5             lequad  4194304         invalid
1793 >1              lelong  8388608
1794 >>5             lequad  8388608         invalid
1795 >1              lelong  16777216
1796 >>5             lequad  16777216        invalid
1797 >1              lelong  33554432
1798 >>5             lequad  33554432        invalid
1799 >5              lequad  x               uncompressed size: %lld bytes
1800
1801
1802 # ------------------------------------------------------------------
1803 # Signature for LZMA compressed data with valid properties byte 0xB5
1804 # ------------------------------------------------------------------
1805 0               string  \xB5\x00\x00    LZMA compressed data, properties: 0xB5,
1806
1807 # These are all the valid dictionary sizes supported by LZMA utils.
1808 >1              lelong  !65536  
1809 >>1             lelong  !131072 
1810 >>>1            lelong  !262144 
1811 >>>>1           lelong  !524288 
1812 >>>>>1          lelong  !1048576        
1813 >>>>>>1         lelong  !2097152        
1814 >>>>>>>1        lelong  !4194304        
1815 >>>>>>>>1       lelong  !8388608        
1816 >>>>>>>>>1      lelong  !16777216       
1817 >>>>>>>>>>1     lelong  !33554432       invalid
1818 >1              lelong  x               dictionary size: %d bytes,
1819
1820 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1821 # This could technically be valid, but is unlikely.
1822 >5              lequad  !-1
1823 >>5             lequad  <32             invalid
1824 >>5             lequad  >0x40000000     invalid
1825
1826 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1827 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1828 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1829 >1              lelong  65536
1830 >>5             lequad  65536           invalid
1831 >1              lelong  131072
1832 >>5             lequad  131072          invalid
1833 >1              lelong  262144
1834 >>5             lequad  262144          invalid
1835 >1              lelong  524288
1836 >>5             lequad  524288          invalid
1837 >1              lelong  1048576
1838 >>5             lequad  1048576         invalid
1839 >1              lelong  2097152
1840 >>5             lequad  2097152         invalid
1841 >1              lelong  4194304
1842 >>5             lequad  4194304         invalid
1843 >1              lelong  8388608
1844 >>5             lequad  8388608         invalid
1845 >1              lelong  16777216
1846 >>5             lequad  16777216        invalid
1847 >1              lelong  33554432
1848 >>5             lequad  33554432        invalid
1849 >5              lequad  x               uncompressed size: %lld bytes
1850
1851
1852 # ------------------------------------------------------------------
1853 # Signature for LZMA compressed data with valid properties byte 0xB6
1854 # ------------------------------------------------------------------
1855 0               string  \xB6\x00\x00    LZMA compressed data, properties: 0xB6,
1856
1857 # These are all the valid dictionary sizes supported by LZMA utils.
1858 >1              lelong  !65536  
1859 >>1             lelong  !131072 
1860 >>>1            lelong  !262144 
1861 >>>>1           lelong  !524288 
1862 >>>>>1          lelong  !1048576        
1863 >>>>>>1         lelong  !2097152        
1864 >>>>>>>1        lelong  !4194304        
1865 >>>>>>>>1       lelong  !8388608        
1866 >>>>>>>>>1      lelong  !16777216       
1867 >>>>>>>>>>1     lelong  !33554432       invalid
1868 >1              lelong  x               dictionary size: %d bytes,
1869
1870 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1871 # This could technically be valid, but is unlikely.
1872 >5              lequad  !-1
1873 >>5             lequad  <32             invalid
1874 >>5             lequad  >0x40000000     invalid
1875
1876 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1877 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1878 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1879 >1              lelong  65536
1880 >>5             lequad  65536           invalid
1881 >1              lelong  131072
1882 >>5             lequad  131072          invalid
1883 >1              lelong  262144
1884 >>5             lequad  262144          invalid
1885 >1              lelong  524288
1886 >>5             lequad  524288          invalid
1887 >1              lelong  1048576
1888 >>5             lequad  1048576         invalid
1889 >1              lelong  2097152
1890 >>5             lequad  2097152         invalid
1891 >1              lelong  4194304
1892 >>5             lequad  4194304         invalid
1893 >1              lelong  8388608
1894 >>5             lequad  8388608         invalid
1895 >1              lelong  16777216
1896 >>5             lequad  16777216        invalid
1897 >1              lelong  33554432
1898 >>5             lequad  33554432        invalid
1899 >5              lequad  x               uncompressed size: %lld bytes
1900
1901
1902 # ------------------------------------------------------------------
1903 # Signature for LZMA compressed data with valid properties byte 0xB7
1904 # ------------------------------------------------------------------
1905 0               string  \xB7\x00\x00    LZMA compressed data, properties: 0xB7,
1906
1907 # These are all the valid dictionary sizes supported by LZMA utils.
1908 >1              lelong  !65536  
1909 >>1             lelong  !131072 
1910 >>>1            lelong  !262144 
1911 >>>>1           lelong  !524288 
1912 >>>>>1          lelong  !1048576        
1913 >>>>>>1         lelong  !2097152        
1914 >>>>>>>1        lelong  !4194304        
1915 >>>>>>>>1       lelong  !8388608        
1916 >>>>>>>>>1      lelong  !16777216       
1917 >>>>>>>>>>1     lelong  !33554432       invalid
1918 >1              lelong  x               dictionary size: %d bytes,
1919
1920 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1921 # This could technically be valid, but is unlikely.
1922 >5              lequad  !-1
1923 >>5             lequad  <32             invalid
1924 >>5             lequad  >0x40000000     invalid
1925
1926 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1927 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1928 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1929 >1              lelong  65536
1930 >>5             lequad  65536           invalid
1931 >1              lelong  131072
1932 >>5             lequad  131072          invalid
1933 >1              lelong  262144
1934 >>5             lequad  262144          invalid
1935 >1              lelong  524288
1936 >>5             lequad  524288          invalid
1937 >1              lelong  1048576
1938 >>5             lequad  1048576         invalid
1939 >1              lelong  2097152
1940 >>5             lequad  2097152         invalid
1941 >1              lelong  4194304
1942 >>5             lequad  4194304         invalid
1943 >1              lelong  8388608
1944 >>5             lequad  8388608         invalid
1945 >1              lelong  16777216
1946 >>5             lequad  16777216        invalid
1947 >1              lelong  33554432
1948 >>5             lequad  33554432        invalid
1949 >5              lequad  x               uncompressed size: %lld bytes
1950
1951
1952 # ------------------------------------------------------------------
1953 # Signature for LZMA compressed data with valid properties byte 0xB8
1954 # ------------------------------------------------------------------
1955 0               string  \xB8\x00\x00    LZMA compressed data, properties: 0xB8,
1956
1957 # These are all the valid dictionary sizes supported by LZMA utils.
1958 >1              lelong  !65536  
1959 >>1             lelong  !131072 
1960 >>>1            lelong  !262144 
1961 >>>>1           lelong  !524288 
1962 >>>>>1          lelong  !1048576        
1963 >>>>>>1         lelong  !2097152        
1964 >>>>>>>1        lelong  !4194304        
1965 >>>>>>>>1       lelong  !8388608        
1966 >>>>>>>>>1      lelong  !16777216       
1967 >>>>>>>>>>1     lelong  !33554432       invalid
1968 >1              lelong  x               dictionary size: %d bytes,
1969
1970 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
1971 # This could technically be valid, but is unlikely.
1972 >5              lequad  !-1
1973 >>5             lequad  <32             invalid
1974 >>5             lequad  >0x40000000     invalid
1975
1976 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
1977 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
1978 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
1979 >1              lelong  65536
1980 >>5             lequad  65536           invalid
1981 >1              lelong  131072
1982 >>5             lequad  131072          invalid
1983 >1              lelong  262144
1984 >>5             lequad  262144          invalid
1985 >1              lelong  524288
1986 >>5             lequad  524288          invalid
1987 >1              lelong  1048576
1988 >>5             lequad  1048576         invalid
1989 >1              lelong  2097152
1990 >>5             lequad  2097152         invalid
1991 >1              lelong  4194304
1992 >>5             lequad  4194304         invalid
1993 >1              lelong  8388608
1994 >>5             lequad  8388608         invalid
1995 >1              lelong  16777216
1996 >>5             lequad  16777216        invalid
1997 >1              lelong  33554432
1998 >>5             lequad  33554432        invalid
1999 >5              lequad  x               uncompressed size: %lld bytes
2000
2001
2002 # ------------------------------------------------------------------
2003 # Signature for LZMA compressed data with valid properties byte 0xBD
2004 # ------------------------------------------------------------------
2005 0               string  \xBD\x00\x00    LZMA compressed data, properties: 0xBD,
2006
2007 # These are all the valid dictionary sizes supported by LZMA utils.
2008 >1              lelong  !65536  
2009 >>1             lelong  !131072 
2010 >>>1            lelong  !262144 
2011 >>>>1           lelong  !524288 
2012 >>>>>1          lelong  !1048576        
2013 >>>>>>1         lelong  !2097152        
2014 >>>>>>>1        lelong  !4194304        
2015 >>>>>>>>1       lelong  !8388608        
2016 >>>>>>>>>1      lelong  !16777216       
2017 >>>>>>>>>>1     lelong  !33554432       invalid
2018 >1              lelong  x               dictionary size: %d bytes,
2019
2020 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2021 # This could technically be valid, but is unlikely.
2022 >5              lequad  !-1
2023 >>5             lequad  <32             invalid
2024 >>5             lequad  >0x40000000     invalid
2025
2026 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2027 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2028 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2029 >1              lelong  65536
2030 >>5             lequad  65536           invalid
2031 >1              lelong  131072
2032 >>5             lequad  131072          invalid
2033 >1              lelong  262144
2034 >>5             lequad  262144          invalid
2035 >1              lelong  524288
2036 >>5             lequad  524288          invalid
2037 >1              lelong  1048576
2038 >>5             lequad  1048576         invalid
2039 >1              lelong  2097152
2040 >>5             lequad  2097152         invalid
2041 >1              lelong  4194304
2042 >>5             lequad  4194304         invalid
2043 >1              lelong  8388608
2044 >>5             lequad  8388608         invalid
2045 >1              lelong  16777216
2046 >>5             lequad  16777216        invalid
2047 >1              lelong  33554432
2048 >>5             lequad  33554432        invalid
2049 >5              lequad  x               uncompressed size: %lld bytes
2050
2051
2052 # ------------------------------------------------------------------
2053 # Signature for LZMA compressed data with valid properties byte 0xBE
2054 # ------------------------------------------------------------------
2055 0               string  \xBE\x00\x00    LZMA compressed data, properties: 0xBE,
2056
2057 # These are all the valid dictionary sizes supported by LZMA utils.
2058 >1              lelong  !65536  
2059 >>1             lelong  !131072 
2060 >>>1            lelong  !262144 
2061 >>>>1           lelong  !524288 
2062 >>>>>1          lelong  !1048576        
2063 >>>>>>1         lelong  !2097152        
2064 >>>>>>>1        lelong  !4194304        
2065 >>>>>>>>1       lelong  !8388608        
2066 >>>>>>>>>1      lelong  !16777216       
2067 >>>>>>>>>>1     lelong  !33554432       invalid
2068 >1              lelong  x               dictionary size: %d bytes,
2069
2070 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2071 # This could technically be valid, but is unlikely.
2072 >5              lequad  !-1
2073 >>5             lequad  <32             invalid
2074 >>5             lequad  >0x40000000     invalid
2075
2076 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2077 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2078 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2079 >1              lelong  65536
2080 >>5             lequad  65536           invalid
2081 >1              lelong  131072
2082 >>5             lequad  131072          invalid
2083 >1              lelong  262144
2084 >>5             lequad  262144          invalid
2085 >1              lelong  524288
2086 >>5             lequad  524288          invalid
2087 >1              lelong  1048576
2088 >>5             lequad  1048576         invalid
2089 >1              lelong  2097152
2090 >>5             lequad  2097152         invalid
2091 >1              lelong  4194304
2092 >>5             lequad  4194304         invalid
2093 >1              lelong  8388608
2094 >>5             lequad  8388608         invalid
2095 >1              lelong  16777216
2096 >>5             lequad  16777216        invalid
2097 >1              lelong  33554432
2098 >>5             lequad  33554432        invalid
2099 >5              lequad  x               uncompressed size: %lld bytes
2100
2101
2102 # ------------------------------------------------------------------
2103 # Signature for LZMA compressed data with valid properties byte 0xBF
2104 # ------------------------------------------------------------------
2105 0               string  \xBF\x00\x00    LZMA compressed data, properties: 0xBF,
2106
2107 # These are all the valid dictionary sizes supported by LZMA utils.
2108 >1              lelong  !65536  
2109 >>1             lelong  !131072 
2110 >>>1            lelong  !262144 
2111 >>>>1           lelong  !524288 
2112 >>>>>1          lelong  !1048576        
2113 >>>>>>1         lelong  !2097152        
2114 >>>>>>>1        lelong  !4194304        
2115 >>>>>>>>1       lelong  !8388608        
2116 >>>>>>>>>1      lelong  !16777216       
2117 >>>>>>>>>>1     lelong  !33554432       invalid
2118 >1              lelong  x               dictionary size: %d bytes,
2119
2120 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2121 # This could technically be valid, but is unlikely.
2122 >5              lequad  !-1
2123 >>5             lequad  <32             invalid
2124 >>5             lequad  >0x40000000     invalid
2125
2126 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2127 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2128 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2129 >1              lelong  65536
2130 >>5             lequad  65536           invalid
2131 >1              lelong  131072
2132 >>5             lequad  131072          invalid
2133 >1              lelong  262144
2134 >>5             lequad  262144          invalid
2135 >1              lelong  524288
2136 >>5             lequad  524288          invalid
2137 >1              lelong  1048576
2138 >>5             lequad  1048576         invalid
2139 >1              lelong  2097152
2140 >>5             lequad  2097152         invalid
2141 >1              lelong  4194304
2142 >>5             lequad  4194304         invalid
2143 >1              lelong  8388608
2144 >>5             lequad  8388608         invalid
2145 >1              lelong  16777216
2146 >>5             lequad  16777216        invalid
2147 >1              lelong  33554432
2148 >>5             lequad  33554432        invalid
2149 >5              lequad  x               uncompressed size: %lld bytes
2150
2151
2152 # ------------------------------------------------------------------
2153 # Signature for LZMA compressed data with valid properties byte 0xC0
2154 # ------------------------------------------------------------------
2155 0               string  \xC0\x00\x00    LZMA compressed data, properties: 0xC0,
2156
2157 # These are all the valid dictionary sizes supported by LZMA utils.
2158 >1              lelong  !65536  
2159 >>1             lelong  !131072 
2160 >>>1            lelong  !262144 
2161 >>>>1           lelong  !524288 
2162 >>>>>1          lelong  !1048576        
2163 >>>>>>1         lelong  !2097152        
2164 >>>>>>>1        lelong  !4194304        
2165 >>>>>>>>1       lelong  !8388608        
2166 >>>>>>>>>1      lelong  !16777216       
2167 >>>>>>>>>>1     lelong  !33554432       invalid
2168 >1              lelong  x               dictionary size: %d bytes,
2169
2170 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2171 # This could technically be valid, but is unlikely.
2172 >5              lequad  !-1
2173 >>5             lequad  <32             invalid
2174 >>5             lequad  >0x40000000     invalid
2175
2176 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2177 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2178 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2179 >1              lelong  65536
2180 >>5             lequad  65536           invalid
2181 >1              lelong  131072
2182 >>5             lequad  131072          invalid
2183 >1              lelong  262144
2184 >>5             lequad  262144          invalid
2185 >1              lelong  524288
2186 >>5             lequad  524288          invalid
2187 >1              lelong  1048576
2188 >>5             lequad  1048576         invalid
2189 >1              lelong  2097152
2190 >>5             lequad  2097152         invalid
2191 >1              lelong  4194304
2192 >>5             lequad  4194304         invalid
2193 >1              lelong  8388608
2194 >>5             lequad  8388608         invalid
2195 >1              lelong  16777216
2196 >>5             lequad  16777216        invalid
2197 >1              lelong  33554432
2198 >>5             lequad  33554432        invalid
2199 >5              lequad  x               uncompressed size: %lld bytes
2200
2201
2202 # ------------------------------------------------------------------
2203 # Signature for LZMA compressed data with valid properties byte 0xC6
2204 # ------------------------------------------------------------------
2205 0               string  \xC6\x00\x00    LZMA compressed data, properties: 0xC6,
2206
2207 # These are all the valid dictionary sizes supported by LZMA utils.
2208 >1              lelong  !65536  
2209 >>1             lelong  !131072 
2210 >>>1            lelong  !262144 
2211 >>>>1           lelong  !524288 
2212 >>>>>1          lelong  !1048576        
2213 >>>>>>1         lelong  !2097152        
2214 >>>>>>>1        lelong  !4194304        
2215 >>>>>>>>1       lelong  !8388608        
2216 >>>>>>>>>1      lelong  !16777216       
2217 >>>>>>>>>>1     lelong  !33554432       invalid
2218 >1              lelong  x               dictionary size: %d bytes,
2219
2220 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2221 # This could technically be valid, but is unlikely.
2222 >5              lequad  !-1
2223 >>5             lequad  <32             invalid
2224 >>5             lequad  >0x40000000     invalid
2225
2226 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2227 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2228 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2229 >1              lelong  65536
2230 >>5             lequad  65536           invalid
2231 >1              lelong  131072
2232 >>5             lequad  131072          invalid
2233 >1              lelong  262144
2234 >>5             lequad  262144          invalid
2235 >1              lelong  524288
2236 >>5             lequad  524288          invalid
2237 >1              lelong  1048576
2238 >>5             lequad  1048576         invalid
2239 >1              lelong  2097152
2240 >>5             lequad  2097152         invalid
2241 >1              lelong  4194304
2242 >>5             lequad  4194304         invalid
2243 >1              lelong  8388608
2244 >>5             lequad  8388608         invalid
2245 >1              lelong  16777216
2246 >>5             lequad  16777216        invalid
2247 >1              lelong  33554432
2248 >>5             lequad  33554432        invalid
2249 >5              lequad  x               uncompressed size: %lld bytes
2250
2251
2252 # ------------------------------------------------------------------
2253 # Signature for LZMA compressed data with valid properties byte 0xC7
2254 # ------------------------------------------------------------------
2255 0               string  \xC7\x00\x00    LZMA compressed data, properties: 0xC7,
2256
2257 # These are all the valid dictionary sizes supported by LZMA utils.
2258 >1              lelong  !65536  
2259 >>1             lelong  !131072 
2260 >>>1            lelong  !262144 
2261 >>>>1           lelong  !524288 
2262 >>>>>1          lelong  !1048576        
2263 >>>>>>1         lelong  !2097152        
2264 >>>>>>>1        lelong  !4194304        
2265 >>>>>>>>1       lelong  !8388608        
2266 >>>>>>>>>1      lelong  !16777216       
2267 >>>>>>>>>>1     lelong  !33554432       invalid
2268 >1              lelong  x               dictionary size: %d bytes,
2269
2270 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2271 # This could technically be valid, but is unlikely.
2272 >5              lequad  !-1
2273 >>5             lequad  <32             invalid
2274 >>5             lequad  >0x40000000     invalid
2275
2276 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2277 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2278 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2279 >1              lelong  65536
2280 >>5             lequad  65536           invalid
2281 >1              lelong  131072
2282 >>5             lequad  131072          invalid
2283 >1              lelong  262144
2284 >>5             lequad  262144          invalid
2285 >1              lelong  524288
2286 >>5             lequad  524288          invalid
2287 >1              lelong  1048576
2288 >>5             lequad  1048576         invalid
2289 >1              lelong  2097152
2290 >>5             lequad  2097152         invalid
2291 >1              lelong  4194304
2292 >>5             lequad  4194304         invalid
2293 >1              lelong  8388608
2294 >>5             lequad  8388608         invalid
2295 >1              lelong  16777216
2296 >>5             lequad  16777216        invalid
2297 >1              lelong  33554432
2298 >>5             lequad  33554432        invalid
2299 >5              lequad  x               uncompressed size: %lld bytes
2300
2301
2302 # ------------------------------------------------------------------
2303 # Signature for LZMA compressed data with valid properties byte 0xC8
2304 # ------------------------------------------------------------------
2305 0               string  \xC8\x00\x00    LZMA compressed data, properties: 0xC8,
2306
2307 # These are all the valid dictionary sizes supported by LZMA utils.
2308 >1              lelong  !65536  
2309 >>1             lelong  !131072 
2310 >>>1            lelong  !262144 
2311 >>>>1           lelong  !524288 
2312 >>>>>1          lelong  !1048576        
2313 >>>>>>1         lelong  !2097152        
2314 >>>>>>>1        lelong  !4194304        
2315 >>>>>>>>1       lelong  !8388608        
2316 >>>>>>>>>1      lelong  !16777216       
2317 >>>>>>>>>>1     lelong  !33554432       invalid
2318 >1              lelong  x               dictionary size: %d bytes,
2319
2320 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2321 # This could technically be valid, but is unlikely.
2322 >5              lequad  !-1
2323 >>5             lequad  <32             invalid
2324 >>5             lequad  >0x40000000     invalid
2325
2326 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2327 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2328 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2329 >1              lelong  65536
2330 >>5             lequad  65536           invalid
2331 >1              lelong  131072
2332 >>5             lequad  131072          invalid
2333 >1              lelong  262144
2334 >>5             lequad  262144          invalid
2335 >1              lelong  524288
2336 >>5             lequad  524288          invalid
2337 >1              lelong  1048576
2338 >>5             lequad  1048576         invalid
2339 >1              lelong  2097152
2340 >>5             lequad  2097152         invalid
2341 >1              lelong  4194304
2342 >>5             lequad  4194304         invalid
2343 >1              lelong  8388608
2344 >>5             lequad  8388608         invalid
2345 >1              lelong  16777216
2346 >>5             lequad  16777216        invalid
2347 >1              lelong  33554432
2348 >>5             lequad  33554432        invalid
2349 >5              lequad  x               uncompressed size: %lld bytes
2350
2351
2352 # ------------------------------------------------------------------
2353 # Signature for LZMA compressed data with valid properties byte 0xCF
2354 # ------------------------------------------------------------------
2355 0               string  \xCF\x00\x00    LZMA compressed data, properties: 0xCF,
2356
2357 # These are all the valid dictionary sizes supported by LZMA utils.
2358 >1              lelong  !65536  
2359 >>1             lelong  !131072 
2360 >>>1            lelong  !262144 
2361 >>>>1           lelong  !524288 
2362 >>>>>1          lelong  !1048576        
2363 >>>>>>1         lelong  !2097152        
2364 >>>>>>>1        lelong  !4194304        
2365 >>>>>>>>1       lelong  !8388608        
2366 >>>>>>>>>1      lelong  !16777216       
2367 >>>>>>>>>>1     lelong  !33554432       invalid
2368 >1              lelong  x               dictionary size: %d bytes,
2369
2370 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2371 # This could technically be valid, but is unlikely.
2372 >5              lequad  !-1
2373 >>5             lequad  <32             invalid
2374 >>5             lequad  >0x40000000     invalid
2375
2376 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2377 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2378 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2379 >1              lelong  65536
2380 >>5             lequad  65536           invalid
2381 >1              lelong  131072
2382 >>5             lequad  131072          invalid
2383 >1              lelong  262144
2384 >>5             lequad  262144          invalid
2385 >1              lelong  524288
2386 >>5             lequad  524288          invalid
2387 >1              lelong  1048576
2388 >>5             lequad  1048576         invalid
2389 >1              lelong  2097152
2390 >>5             lequad  2097152         invalid
2391 >1              lelong  4194304
2392 >>5             lequad  4194304         invalid
2393 >1              lelong  8388608
2394 >>5             lequad  8388608         invalid
2395 >1              lelong  16777216
2396 >>5             lequad  16777216        invalid
2397 >1              lelong  33554432
2398 >>5             lequad  33554432        invalid
2399 >5              lequad  x               uncompressed size: %lld bytes
2400
2401
2402 # ------------------------------------------------------------------
2403 # Signature for LZMA compressed data with valid properties byte 0xD0
2404 # ------------------------------------------------------------------
2405 0               string  \xD0\x00\x00    LZMA compressed data, properties: 0xD0,
2406
2407 # These are all the valid dictionary sizes supported by LZMA utils.
2408 >1              lelong  !65536  
2409 >>1             lelong  !131072 
2410 >>>1            lelong  !262144 
2411 >>>>1           lelong  !524288 
2412 >>>>>1          lelong  !1048576        
2413 >>>>>>1         lelong  !2097152        
2414 >>>>>>>1        lelong  !4194304        
2415 >>>>>>>>1       lelong  !8388608        
2416 >>>>>>>>>1      lelong  !16777216       
2417 >>>>>>>>>>1     lelong  !33554432       invalid
2418 >1              lelong  x               dictionary size: %d bytes,
2419
2420 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2421 # This could technically be valid, but is unlikely.
2422 >5              lequad  !-1
2423 >>5             lequad  <32             invalid
2424 >>5             lequad  >0x40000000     invalid
2425
2426 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2427 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2428 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2429 >1              lelong  65536
2430 >>5             lequad  65536           invalid
2431 >1              lelong  131072
2432 >>5             lequad  131072          invalid
2433 >1              lelong  262144
2434 >>5             lequad  262144          invalid
2435 >1              lelong  524288
2436 >>5             lequad  524288          invalid
2437 >1              lelong  1048576
2438 >>5             lequad  1048576         invalid
2439 >1              lelong  2097152
2440 >>5             lequad  2097152         invalid
2441 >1              lelong  4194304
2442 >>5             lequad  4194304         invalid
2443 >1              lelong  8388608
2444 >>5             lequad  8388608         invalid
2445 >1              lelong  16777216
2446 >>5             lequad  16777216        invalid
2447 >1              lelong  33554432
2448 >>5             lequad  33554432        invalid
2449 >5              lequad  x               uncompressed size: %lld bytes
2450
2451
2452 # ------------------------------------------------------------------
2453 # Signature for LZMA compressed data with valid properties byte 0xD8
2454 # ------------------------------------------------------------------
2455 0               string  \xD8\x00\x00    LZMA compressed data, properties: 0xD8,
2456
2457 # These are all the valid dictionary sizes supported by LZMA utils.
2458 >1              lelong  !65536  
2459 >>1             lelong  !131072 
2460 >>>1            lelong  !262144 
2461 >>>>1           lelong  !524288 
2462 >>>>>1          lelong  !1048576        
2463 >>>>>>1         lelong  !2097152        
2464 >>>>>>>1        lelong  !4194304        
2465 >>>>>>>>1       lelong  !8388608        
2466 >>>>>>>>>1      lelong  !16777216       
2467 >>>>>>>>>>1     lelong  !33554432       invalid
2468 >1              lelong  x               dictionary size: %d bytes,
2469
2470 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2471 # This could technically be valid, but is unlikely.
2472 >5              lequad  !-1
2473 >>5             lequad  <32             invalid
2474 >>5             lequad  >0x40000000     invalid
2475
2476 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2477 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2478 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2479 >1              lelong  65536
2480 >>5             lequad  65536           invalid
2481 >1              lelong  131072
2482 >>5             lequad  131072          invalid
2483 >1              lelong  262144
2484 >>5             lequad  262144          invalid
2485 >1              lelong  524288
2486 >>5             lequad  524288          invalid
2487 >1              lelong  1048576
2488 >>5             lequad  1048576         invalid
2489 >1              lelong  2097152
2490 >>5             lequad  2097152         invalid
2491 >1              lelong  4194304
2492 >>5             lequad  4194304         invalid
2493 >1              lelong  8388608
2494 >>5             lequad  8388608         invalid
2495 >1              lelong  16777216
2496 >>5             lequad  16777216        invalid
2497 >1              lelong  33554432
2498 >>5             lequad  33554432        invalid
2499 >5              lequad  x               uncompressed size: %lld bytes
2500