Imported Upstream version 1.2.1
[packages/binwalk.git] / magic / lzma
index 800876c..d735105 100644 (file)
 
 # ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x5D
-# ------------------------------------------------------------------
-0              string  \x5D\x00\x00    LZMA compressed data, properties: 0x5D,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x01
-# ------------------------------------------------------------------
-0              string  \x01\x00\x00    LZMA compressed data, properties: 0x01,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x02
-# ------------------------------------------------------------------
-0              string  \x02\x00\x00    LZMA compressed data, properties: 0x02,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x03
-# ------------------------------------------------------------------
-0              string  \x03\x00\x00    LZMA compressed data, properties: 0x03,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x04
-# ------------------------------------------------------------------
-0              string  \x04\x00\x00    LZMA compressed data, properties: 0x04,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x09
-# ------------------------------------------------------------------
-0              string  \x09\x00\x00    LZMA compressed data, properties: 0x09,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x0A
-# ------------------------------------------------------------------
-0              string  \x0A\x00\x00    LZMA compressed data, properties: 0x0A,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x0B
-# ------------------------------------------------------------------
-0              string  \x0B\x00\x00    LZMA compressed data, properties: 0x0B,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x0C
-# ------------------------------------------------------------------
-0              string  \x0C\x00\x00    LZMA compressed data, properties: 0x0C,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x12
-# ------------------------------------------------------------------
-0              string  \x12\x00\x00    LZMA compressed data, properties: 0x12,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x13
-# ------------------------------------------------------------------
-0              string  \x13\x00\x00    LZMA compressed data, properties: 0x13,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x14
-# ------------------------------------------------------------------
-0              string  \x14\x00\x00    LZMA compressed data, properties: 0x14,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x1B
-# ------------------------------------------------------------------
-0              string  \x1B\x00\x00    LZMA compressed data, properties: 0x1B,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x1C
-# ------------------------------------------------------------------
-0              string  \x1C\x00\x00    LZMA compressed data, properties: 0x1C,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x24
-# ------------------------------------------------------------------
-0              string  \x24\x00\x00    LZMA compressed data, properties: 0x24,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x2D
-# ------------------------------------------------------------------
-0              string  \x2D\x00\x00    LZMA compressed data, properties: 0x2D,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x2E
-# ------------------------------------------------------------------
-0              string  \x2E\x00\x00    LZMA compressed data, properties: 0x2E,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x2F
-# ------------------------------------------------------------------
-0              string  \x2F\x00\x00    LZMA compressed data, properties: 0x2F,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x30
-# ------------------------------------------------------------------
-0              string  \x30\x00\x00    LZMA compressed data, properties: 0x30,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x31
-# ------------------------------------------------------------------
-0              string  \x31\x00\x00    LZMA compressed data, properties: 0x31,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x36
-# ------------------------------------------------------------------
-0              string  \x36\x00\x00    LZMA compressed data, properties: 0x36,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x37
-# ------------------------------------------------------------------
-0              string  \x37\x00\x00    LZMA compressed data, properties: 0x37,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x38
-# ------------------------------------------------------------------
-0              string  \x38\x00\x00    LZMA compressed data, properties: 0x38,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x39
-# ------------------------------------------------------------------
-0              string  \x39\x00\x00    LZMA compressed data, properties: 0x39,
-
-# These are all the valid dictionary sizes supported by LZMA utils.
->1             lelong  !65536  
->>1            lelong  !131072 
->>>1           lelong  !262144 
->>>>1          lelong  !524288 
->>>>>1         lelong  !1048576        
->>>>>>1                lelong  !2097152        
->>>>>>>1       lelong  !4194304        
->>>>>>>>1      lelong  !8388608        
->>>>>>>>>1     lelong  !16777216       
->>>>>>>>>>1    lelong  !33554432       invalid
->1             lelong  x               dictionary size: %d bytes,
-
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
-
-# These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
-# Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
-# marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
->1             lelong  65536
->>5            lequad  65536           invalid
->1             lelong  131072
->>5            lequad  131072          invalid
->1             lelong  262144
->>5            lequad  262144          invalid
->1             lelong  524288
->>5            lequad  524288          invalid
->1             lelong  1048576
->>5            lequad  1048576         invalid
->1             lelong  2097152
->>5            lequad  2097152         invalid
->1             lelong  4194304
->>5            lequad  4194304         invalid
->1             lelong  8388608
->>5            lequad  8388608         invalid
->1             lelong  16777216
->>5            lequad  16777216        invalid
->1             lelong  33554432
->>5            lequad  33554432        invalid
->5             lequad  x               uncompressed size: %lld bytes
-
-
-# ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x3F
+# Signature for LZMA compressed data with valid properties byte 0x40
 # ------------------------------------------------------------------
-0              string  \x3F\x00\x00    LZMA compressed data, properties: 0x3F,
+0              string  \x40\x00\x00    LZMA compressed data, properties: 0x40,
 
 # These are all the valid dictionary sizes supported by LZMA utils.
 >1             lelong  !65536  
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 
 
 # ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x40
+# Signature for LZMA compressed data with valid properties byte 0x41
 # ------------------------------------------------------------------
-0              string  \x40\x00\x00    LZMA compressed data, properties: 0x40,
+0              string  \x41\x00\x00    LZMA compressed data, properties: 0x41,
 
 # These are all the valid dictionary sizes supported by LZMA utils.
 >1             lelong  !65536  
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 
 
 # ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x41
+# Signature for LZMA compressed data with valid properties byte 0x48
 # ------------------------------------------------------------------
-0              string  \x41\x00\x00    LZMA compressed data, properties: 0x41,
+0              string  \x48\x00\x00    LZMA compressed data, properties: 0x48,
 
 # These are all the valid dictionary sizes supported by LZMA utils.
 >1             lelong  !65536  
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 
 
 # ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x48
+# Signature for LZMA compressed data with valid properties byte 0x49
 # ------------------------------------------------------------------
-0              string  \x48\x00\x00    LZMA compressed data, properties: 0x48,
+0              string  \x49\x00\x00    LZMA compressed data, properties: 0x49,
 
 # These are all the valid dictionary sizes supported by LZMA utils.
 >1             lelong  !65536  
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 
 
 # ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x49
+# Signature for LZMA compressed data with valid properties byte 0x51
 # ------------------------------------------------------------------
-0              string  \x49\x00\x00    LZMA compressed data, properties: 0x49,
+0              string  \x51\x00\x00    LZMA compressed data, properties: 0x51,
 
 # These are all the valid dictionary sizes supported by LZMA utils.
 >1             lelong  !65536  
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 
 
 # ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x51
+# Signature for LZMA compressed data with valid properties byte 0x5A
 # ------------------------------------------------------------------
-0              string  \x51\x00\x00    LZMA compressed data, properties: 0x51,
+0              string  \x5A\x00\x00    LZMA compressed data, properties: 0x5A,
 
 # These are all the valid dictionary sizes supported by LZMA utils.
 >1             lelong  !65536  
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 
 
 # ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x5A
+# Signature for LZMA compressed data with valid properties byte 0x5B
 # ------------------------------------------------------------------
-0              string  \x5A\x00\x00    LZMA compressed data, properties: 0x5A,
+0              string  \x5B\x00\x00    LZMA compressed data, properties: 0x5B,
 
 # These are all the valid dictionary sizes supported by LZMA utils.
 >1             lelong  !65536  
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 
 
 # ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x5B
+# Signature for LZMA compressed data with valid properties byte 0x5C
 # ------------------------------------------------------------------
-0              string  \x5B\x00\x00    LZMA compressed data, properties: 0x5B,
+0              string  \x5C\x00\x00    LZMA compressed data, properties: 0x5C,
 
 # These are all the valid dictionary sizes supported by LZMA utils.
 >1             lelong  !65536  
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 
 
 # ------------------------------------------------------------------
-# Signature for LZMA compressed data with valid properties byte 0x5C
+# Signature for LZMA compressed data with valid properties byte 0x5D
 # ------------------------------------------------------------------
-0              string  \x5C\x00\x00    LZMA compressed data, properties: 0x5C,
+0              string  \x5D\x00\x00    LZMA compressed data, properties: 0x5D,
 
 # These are all the valid dictionary sizes supported by LZMA utils.
 >1             lelong  !65536  
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
 >>>>>>>>>>1    lelong  !33554432       invalid
 >1             lelong  x               dictionary size: %d bytes,
 
-# Assume that a valid size will be less than 1GB. This could technically be valid, but is unlikely.
->5             lequad  <1              invalid
->5             lequad  >0x40000000     invalid
+# Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
+# This could technically be valid, but is unlikely.
+>5             lequad  !-1
+>>5            lequad  <32             invalid
+>>5            lequad  >0x40000000     invalid
 
 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),