START	usr.bin/gzip	2024-11-05T20:59:42Z

==== run-regress-integrity ====

==== run-regress-integrity ====
# create gz
gzip -v </etc/rc >rc.gz
17319 bytes in, 6721 bytes out
# check that everything is ok
gzip -vt rc.gz
rc.gz:	OK

==== run-regress-truncate-2k ====

==== run-regress-truncate-2k ====
# truncate at 2k
gzip </etc/rc >rc.gz
dd if=rc.gz bs=1k count=2 of=2k.gz
2+0 records in
2+0 records out
2048 bytes transferred in 0.000 secs (20664742 bytes/sec)
# check that truncation is detected
! gzip -vt 2k.gz
2k.gz:	gzip: 2k.gz: Input/output error

==== run-regress-truncate-1k ====

==== run-regress-truncate-1k ====
# truncate at 1k
gzip </etc/rc >rc.gz
dd if=rc.gz bs=1k count=1 of=1k.gz
1+0 records in
1+0 records out
1024 bytes transferred in 0.000 secs (15209125 bytes/sec)
# check that truncation is detected
! gzip -vt 1k.gz
1k.gz:	gzip: 1k.gz: Input/output error

==== run-regress-skip ====

==== run-regress-skip ====
# skip some data in the middle
gzip </etc/rc >rc.gz
dd if=rc.gz bs=1k count=1 of=skip.gz
1+0 records in
1+0 records out
1024 bytes transferred in 0.000 secs (15465708 bytes/sec)
dd if=rc.gz bs=1k seek=2 skip=2 conv=notrunc of=skip.gz
4+1 records in
4+1 records out
4673 bytes transferred in 0.000 secs (95445261 bytes/sec)
# check that corruption is detected
! gzip -vt skip.gz
skip.gz:	gzip: skip.gz: crc error
OK

==== run-regress-fuzz ====

==== run-regress-fuzz ====
# simple fuzzer that modifies one random byte at a random offset
gzip </etc/rc >rc.gz
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=1; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "1/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
1/100: fuzzing byte @1958: 80 -> 231
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=2; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "2/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
2/100: fuzzing byte @1555: 96 -> 80
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=3; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "3/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
3/100: fuzzing byte @1152: 147 -> 185
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=4; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "4/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
4/100: fuzzing byte @749: 136 -> 34
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=5; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "5/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
5/100: fuzzing byte @346: 73 -> 139
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=6; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "6/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
6/100: fuzzing byte @1991: 225 -> 244
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=7; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "7/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
7/100: fuzzing byte @1588: 220 -> 93
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=8; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "8/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
8/100: fuzzing byte @1185: 140 -> 198
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=9; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "9/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
9/100: fuzzing byte @782: 99 -> 47
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=10; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "10/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
10/100: fuzzing byte @379: 137 -> 152
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=11; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "11/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
11/100: fuzzing byte @2024: 246 -> 1
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=12; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "12/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
12/100: fuzzing byte @1621: 66 -> 106
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=13; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "13/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
13/100: fuzzing byte @1218: 0 -> 211
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=14; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "14/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
14/100: fuzzing byte @815: 180 -> 60
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=15; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "15/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
15/100: fuzzing byte @412: 113 -> 165
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=16; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "16/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
16/100: fuzzing byte @2057: 106 -> 14
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=17; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "17/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
17/100: fuzzing byte @1654: 180 -> 119
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=18; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "18/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
18/100: fuzzing byte @1251: 196 -> 224
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=19; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "19/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
19/100: fuzzing byte @848: 225 -> 73
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=20; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "20/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
20/100: fuzzing byte @445: 164 -> 178
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=21; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "21/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
21/100: fuzzing byte @2090: 209 -> 27
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=22; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "22/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
22/100: fuzzing byte @1687: 125 -> 132
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=23; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "23/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
23/100: fuzzing byte @1284: 37 -> 237
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=24; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "24/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
24/100: fuzzing byte @881: 169 -> 86
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=25; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "25/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
25/100: fuzzing byte @478: 51 -> 191
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=26; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "26/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
26/100: fuzzing byte @2123: 203 -> 40
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=27; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "27/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
27/100: fuzzing byte @1720: 114 -> 145
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=28; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "28/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
28/100: fuzzing byte @1317: 182 -> 250
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=29; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "29/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
29/100: fuzzing byte @914: 54 -> 99
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=30; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "30/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
30/100: fuzzing byte @511: 141 -> 204
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=31; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "31/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
31/100: fuzzing byte @2156: 215 -> 53
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=32; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "32/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
32/100: fuzzing byte @1753: 243 -> 158
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=33; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "33/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
33/100: fuzzing byte @1350: 173 -> 7
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=34; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "34/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
34/100: fuzzing byte @947: 164 -> 112
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=35; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "35/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
35/100: fuzzing byte @544: 120 -> 217
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=36; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "36/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
36/100: fuzzing byte @2189: 59 -> 66
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=37; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "37/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
37/100: fuzzing byte @1786: 235 -> 171
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=38; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "38/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
38/100: fuzzing byte @1383: 53 -> 20
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=39; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "39/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
39/100: fuzzing byte @980: 104 -> 125
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=40; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "40/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
40/100: fuzzing byte @577: 75 -> 230
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=41; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "41/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
41/100: fuzzing byte @2222: 40 -> 79
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=42; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "42/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
42/100: fuzzing byte @1819: 130 -> 184
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=43; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "43/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
43/100: fuzzing byte @1416: 85 -> 33
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=44; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "44/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
44/100: fuzzing byte @1013: 104 -> 138
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=45; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "45/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
45/100: fuzzing byte @610: 106 -> 243
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=46; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "46/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
46/100: fuzzing byte @2255: 35 -> 92
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=47; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "47/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
47/100: fuzzing byte @1852: 119 -> 197
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=48; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "48/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
48/100: fuzzing byte @1449: 52 -> 46
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=49; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "49/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
49/100: fuzzing byte @1046: 182 -> 151
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=50; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "50/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
50/100: fuzzing byte @643: 144 -> 0
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=51; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "51/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
51/100: fuzzing byte @2288: 78 -> 105
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=52; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "52/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
52/100: fuzzing byte @1885: 172 -> 210
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=53; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "53/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
53/100: fuzzing byte @1482: 96 -> 59
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=54; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "54/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
54/100: fuzzing byte @1079: 210 -> 164
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=55; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "55/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
55/100: fuzzing byte @676: 136 -> 13
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=56; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "56/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
56/100: fuzzing byte @273: 97 -> 118
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=57; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "57/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
57/100: fuzzing byte @1918: 56 -> 223
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=58; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "58/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
58/100: fuzzing byte @1515: 144 -> 72
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=59; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "59/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
59/100: fuzzing byte @1112: 11 -> 177
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=60; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "60/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
60/100: fuzzing byte @709: 52 -> 26
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=61; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "61/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
61/100: fuzzing byte @306: 148 -> 131
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=62; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "62/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
62/100: fuzzing byte @1951: 61 -> 236
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=63; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "63/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
63/100: fuzzing byte @1548: 154 -> 85
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=64; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "64/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
64/100: fuzzing byte @1145: 43 -> 190
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=65; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "65/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
65/100: fuzzing byte @742: 138 -> 39
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=66; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "66/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
66/100: fuzzing byte @339: 169 -> 144
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=67; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "67/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
67/100: fuzzing byte @1984: 96 -> 249
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=68; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "68/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
68/100: fuzzing byte @1581: 102 -> 98
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=69; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "69/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
69/100: fuzzing byte @1178: 137 -> 203
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=70; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "70/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
70/100: fuzzing byte @775: 136 -> 52
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=71; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "71/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
71/100: fuzzing byte @372: 197 -> 157
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=72; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "72/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
72/100: fuzzing byte @2017: 140 -> 6
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=73; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "73/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
73/100: fuzzing byte @1614: 68 -> 111
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=74; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "74/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
74/100: fuzzing byte @1211: 163 -> 216
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=75; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "75/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
75/100: fuzzing byte @808: 5 -> 65
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=76; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "76/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
76/100: fuzzing byte @405: 155 -> 170
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=77; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "77/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
77/100: fuzzing byte @2050: 120 -> 19
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=78; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "78/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
78/100: fuzzing byte @1647: 65 -> 124
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=79; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "79/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
79/100: fuzzing byte @1244: 134 -> 229
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=80; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "80/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
80/100: fuzzing byte @841: 53 -> 78
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=81; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "81/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
81/100: fuzzing byte @438: 136 -> 183
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=82; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "82/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
82/100: fuzzing byte @2083: 10 -> 32
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=83; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "83/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
83/100: fuzzing byte @1680: 207 -> 137
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=84; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "84/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
84/100: fuzzing byte @1277: 86 -> 242
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=85; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "85/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
85/100: fuzzing byte @874: 160 -> 91
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=86; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "86/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
86/100: fuzzing byte @471: 120 -> 196
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=87; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "87/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
87/100: fuzzing byte @2116: 5 -> 45
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=88; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "88/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
88/100: fuzzing byte @1713: 118 -> 150
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=89; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "89/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
89/100: fuzzing byte @1310: 234 -> 255
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=90; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "90/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
90/100: fuzzing byte @907: 64 -> 104
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=91; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "91/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
91/100: fuzzing byte @504: 23 -> 209
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=92; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "92/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
92/100: fuzzing byte @2149: 211 -> 58
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=93; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "93/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
93/100: fuzzing byte @1746: 2 -> 163
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=94; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "94/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
94/100: fuzzing byte @1343: 173 -> 12
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=95; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "95/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
95/100: fuzzing byte @940: 120 -> 117
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=96; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "96/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
96/100: fuzzing byte @537: 202 -> 222
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=97; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "97/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
97/100: fuzzing byte @2182: 204 -> 71
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=98; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "98/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
98/100: fuzzing byte @1779: 200 -> 176
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=99; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "99/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
99/100: fuzzing byte @1376: 58 -> 25
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK
dd if=rc.gz bs=1k of=fuzz.gz status=none
RANDOM=100; where=$((RANDOM % 2048 + 256)); fuzz=$((RANDOM % 256)); orig=`dd if=rc.gz bs=1 skip=$where count=1 status=none | hexdump -e '"%d"'`; echo "100/100: fuzzing byte @$where: $orig -> $fuzz"; echo -n \\0`printf "%o" $fuzz` | dd bs=1 seek=$where conv=notrunc of=fuzz.gz status=none
100/100: fuzzing byte @973: 203 -> 130
cmp -s rc.gz fuzz.gz || ! gzip -vt fuzz.gz
fuzz.gz:	gzip: fuzz.gz: crc error
OK

==== run-regress-gunzip ====

==== run-regress-gunzip ====
# gzip and gunzip
gzip -v </etc/rc >rc.gz
17319 bytes in, 6721 bytes out
gunzip -f rc.gz
# check that uncompressed file does match
diff -up /etc/rc rc

==== run-regress-multi ====

==== run-regress-multi ====
# compress multiple files
gzip -c /etc/rc /etc/motd >multi.gz
# check multiple gzip file
gzip -vt multi.gz
multi.gz:	OK
gunzip -f multi.gz
# check that gunzipped files do match
cat /etc/rc /etc/motd >rcmotd
diff -up rcmotd multi

==== run-regress-name ====

==== run-regress-name ====
# check gunzip -N
gzip -c /etc/rc >in.gz
rm -f rc
gunzip -N in.gz
diff -up /etc/rc rc
# check that -N works with -l
gzip -c /etc/rc >in.gz
gzip -lN in.gz | grep -q ' rc$'
gzip -lN <in.gz | grep -q ' rc$'
# check that stdout ignores -N
rm -f out
gzip -dN <in.gz >out
diff -up /etc/rc out
# check that zcat ignores -N
rm -f out
zcat -N in.gz >out
diff -up /etc/rc out

==== run-regress-perm-zip ====

==== run-regress-perm-zip ====
# compress file with special permissions
cat /etc/rc >perm
chmod 614 perm
rm -f perm.gz
gzip perm
ls -l perm.gz | grep '^-rw---xr-- '
-rw---xr--  1 root  wobj  6726 Nov  5 21:59 perm.gz

==== run-regress-perm-unzip ====

==== run-regress-perm-unzip ====
# uncompress file with special permissions
gzip </etc/rc >perm.gz
chmod 614 perm.gz
rm -f perm
gunzip perm.gz
ls -l perm | grep '^-rw---xr-- '
-rw---xr--  1 root  wobj  17319 Nov  5 21:59 perm

==== run-regress-owner-zip ====

==== run-regress-owner-zip ====
# compress file as root with user and group nobody
rm -f owner
cat /etc/rc >owner
chown nobody:nobody owner
rm -f owner.gz
gzip owner
ls -l owner.gz | grep ' nobody  *nobody '
-rw-r--r--  1 nobody  nobody  6727 Nov  5 21:59 owner.gz

==== run-regress-owner-unzip ====

==== run-regress-owner-unzip ====
# uncompress file with special permissions
rm -f owner.gz
gzip </etc/rc >owner.gz
chown nobody:nobody owner.gz
rm -f owner
gunzip owner.gz
ls -l owner | grep ' nobody  *nobody '
-rw-r--r--  1 nobody  nobody  17319 Nov  5 21:59 owner

PASS	usr.bin/gzip	Duration 0m02.94s