diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..836ac06
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,187 @@
+name: CI
+
+on:
+  push:
+    branches: [ master, main ]
+  pull_request:
+    branches: [ master, main ]
+
+jobs:
+  linux:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y libyaml-dev ragel
+
+    - name: Build CLI tools
+      run: |
+        cd src
+        make dns cache spf zone
+
+    - name: Run tests
+      run: |
+        cd regress
+        make check
+
+    - name: Test CLI tools
+      run: |
+        cd src
+        ./dns -V
+        ./dns parse-domain example.com
+        ./dns print-arpa 192.168.1.1
+        ./cache -h
+        ./zone -h
+        ./spf -h
+
+  mingw:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y mingw-w64
+
+    - name: Build CLI tools
+      run: |
+        cd src
+        make dns.exe
+
+  macos:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install dependencies
+      run: |
+        brew install libyaml ragel
+
+    - name: Build CLI tools
+      run: |
+        cd src
+        make dns cache spf zone
+
+    - name: Run tests
+      env:
+        CPPFLAGS: -I/opt/homebrew/include
+        LDFLAGS: -L/opt/homebrew/lib
+      run: |
+        cd regress
+        make check
+
+    - name: Test CLI tools
+      run: |
+        cd src
+        ./dns -V
+        ./dns parse-domain example.com
+        ./dns print-arpa 192.168.1.1
+        ./cache -h
+        ./zone -h
+        ./spf -h
+
+  windows:
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Setup MSVC
+      uses: ilammy/msvc-dev-cmd@v1
+
+    - name: Install dependencies
+      run: |
+        vcpkg install getopt:x64-windows
+
+    - name: Build CLI tools
+      shell: cmd
+      run: |
+        cd src
+        clang-cl /nologo /W3 /DDNS_DEBUG=0 /DDNS_MAIN /D_CRT_SECURE_NO_WARNINGS /D_WINSOCK_DEPRECATED_NO_WARNINGS /I"%VCPKG_INSTALLATION_ROOT%\installed\x64-windows\include" dns.c /link /LIBPATH:"%VCPKG_INSTALLATION_ROOT%\installed\x64-windows\lib" getopt.lib ws2_32.lib iphlpapi.lib advapi32.lib /out:dns.exe
+
+    - name: Test CLI tools
+      shell: cmd
+      run: |
+        set PATH=%VCPKG_INSTALLATION_ROOT%\installed\x64-windows\bin;%PATH%
+        cd src
+        dns.exe -V
+        dns.exe parse-domain example.com
+        dns.exe print-arpa 192.168.1.1
+
+#  freebsd:
+#    runs-on: ubuntu-latest
+#    steps:
+#    - uses: actions/checkout@v4
+#    - name: Build and test on FreeBSD
+#      uses: vmactions/freebsd-vm@v1
+#      with:
+#        usesh: true
+#        run: |
+#          pkg install -y ragel libyaml
+#          cd src
+#          cc -std=gnu99 -Wall -Wextra -Wshadow -Wstrict-prototypes -Wmissing-prototypes -Wold-style-definition -Werror -g -DDNS_DEBUG=0 -c dns.c -o dns.o
+#          cc -std=gnu99 -Wall -Wextra -Wshadow -Wstrict-prototypes -Wmissing-prototypes -Wold-style-definition -Werror -g -DDNS_DEBUG=0 -DDNS_MAIN -o dns dns.c
+#          ./dns -V
+#          cc -std=gnu99 -Wall -Wextra -Wshadow -Wstrict-prototypes -Wmissing-prototypes -Wold-style-definition -Werror -g -c cache.c -o cache.o
+#          cc -std=gnu99 -Wall -Wextra -Wshadow -Wstrict-prototypes -Wmissing-prototypes -Wold-style-definition -Werror -g -DCACHE_MAIN -o cache cache.c
+#          ./cache -V
+#          cd ../regress
+#          make check
+
+#  openindiana:
+#    runs-on: ubuntu-latest
+#    steps:
+#    - uses: actions/checkout@v4
+#    - name: Build and test on OpenIndiana
+#      uses: vmactions/openindiana-vm@v1
+#      with:
+#        run: |
+#          pkg install developer/gcc
+#          cd src
+#          gcc -std=gnu99 -Wall -Wextra -Wshadow -Wstrict-prototypes -Wmissing-prototypes -Wold-style-definition -Werror -g -DDNS_DEBUG=0 -c dns.c -o dns.o
+#          gcc -std=gnu99 -Wall -Wextra -Wshadow -Wstrict-prototypes -Wmissing-prototypes -Wold-style-definition -Werror -g -DDNS_DEBUG=0 -DDNS_MAIN -o dns dns.c
+#          ./dns -V
+#          cc -std=gnu99 -Wall -Wextra -Wshadow -Wstrict-prototypes -Wmissing-prototypes -Wold-style-definition -Werror -g -c cache.c -o cache.o
+#          cc -std=gnu99 -Wall -Wextra -Wshadow -Wstrict-prototypes -Wmissing-prototypes -Wold-style-definition -Werror -g -DCACHE_MAIN -o cache cache.c
+#          ./cache -V
+#          make check
+
+  fuzz:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install LLVM
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y clang llvm
+
+    - name: Build fuzzer
+      run: |
+        cd regress
+        clang -g -O1 -fsanitize=fuzzer,address,undefined \
+              -DDNS_DEBUG=0 -I../src -o fuzz_dns fuzz_dns.c
+
+    - name: Create corpus directory with existing crash files
+      run: |
+        mkdir -p regress/corpus
+        cp regress/crash-* regress/corpus/ 2>/dev/null || true
+
+    - name: Run fuzzer
+      run: |
+        cd regress
+        timeout 330 ./fuzz_dns corpus/ -max_len=4096 -max_total_time=300 || test $? -eq 124
+
+    - name: Upload crash artifacts
+      if: always()
+      uses: actions/upload-artifact@v4
+      with:
+        name: fuzz-crashes
+        path: |
+          regress/crash-*
+          regress/oom-*
+          regress/timeout-*
+        if-no-files-found: ignore
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..e99b7b0
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,35 @@
+*~
+*.a
+*.dll
+*.dylib
+*.exe
+*.exp
+*.lib
+*.map
+*.o
+*.obj
+*.pc
+*.pyc
+*.so
+.*.sw?
+*cscope.in.out
+*cscope.out
+*cscope.po.out
+contrib/socket
+src/dns
+src/spf.c
+src/zone.c
+regress/20-rr-parse
+regress/fuzz_dns
+doc/dns.aux
+doc/dns.glg
+doc/dns.glo
+doc/dns.gls
+doc/dns.idx
+doc/dns.ilg
+doc/dns.ind
+doc/dns.ist
+doc/dns.log
+doc/dns.out
+doc/dns.pdf
+doc/dns.toc
diff --git a/contrib/Makefile b/contrib/Makefile
index 41a7a98..dc60ead 100644
--- a/contrib/Makefile
+++ b/contrib/Makefile
@@ -3,7 +3,7 @@ cc-option = $(shell if $(CC) $(CFLAGS) $(1) -S -o /dev/null -xc /dev/null \
 	> /dev/null 2>&1; then echo "$(1)"; else echo "$(2)"; fi;)
 
 override CPPFLAGS := $(CPPFLAGS) -I../src -DSOCKET_DEBUG -DSOCKET_MAIN
-override CFLAGS   := $(CFLAGS) -std=gnu99 -Wall -Wno-unused-function -Wno-unused-parameter $(call cc-option, -Wno-initializer-overrides,) -O2 -g -fstack-protector
+override CFLAGS   := $(CFLAGS) -std=gnu99 -Wall -Wno-unused-function -Wno-unused-parameter $(call cc-option, -Wno-initializer-overrides, $(call cc-option, -Wno-override-init,)) -O2 -g -fstack-protector
 override LIBS     := -lssl -lcrypto
 
 ifeq ($(shell uname -s), Darwin)
diff --git a/contrib/socket.c b/contrib/socket.c
index 1b1c7fd..78e2d06 100644
--- a/contrib/socket.c
+++ b/contrib/socket.c
@@ -202,7 +202,6 @@ static void so_trace(enum so_trace event, int fd, const struct addrinfo *host, .
 	char addr[64], who[256];
 	in_port_t port;
 	va_list ap;
-	SSL *ctx;
 	const void *data;
 	size_t count;
 	const char *fmt;
@@ -240,7 +239,7 @@ static void so_trace(enum so_trace event, int fd, const struct addrinfo *host, .
 
 		break;
 	case SO_T_STARTTLS:
-		ctx = va_arg(ap, SSL *);
+		(void)va_arg(ap, SSL *); /* ctx - unused */
 		fmt = va_arg(ap, char *);
 
 		fprintf(stderr, "starttls(%s): ", who);
@@ -1633,16 +1632,24 @@ int so_starttls(struct socket *so, SSL_CTX *ctx) {
 		goto error;
 
 	/*
-	 * NOTE: SSLv3_server_method()->ssl_connect should be a reference to
-	 * OpenSSL's internal ssl_undefined_function().
+	 * Detect whether the SSL context is configured for server mode.
 	 *
-	 * Server methods such as SSLv23_server_method(), etc. should have
-	 * their .ssl_connect method set to this value.
+	 * For OpenSSL < 1.1.0, we checked internal method pointers, but
+	 * that API is no longer available (SSL_METHOD is now opaque and
+	 * SSLv3_server_method() was removed).
+	 *
+	 * For OpenSSL 1.1.0+, we default to client mode. Server sockets
+	 * should have so->todo containing SO_S_LISTEN if so_listen() was
+	 * called, which we use to detect server mode.
 	 */
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+	(void)method;
+	so->ssl.accept = (so->todo & SO_S_LISTEN) ? 1 : 0;
+#else
 	method = SSL_get_ssl_method(so->ssl.ctx);
-
 	if (!method->ssl_connect || method->ssl_connect == SSLv3_server_method()->ssl_connect)
 		so->ssl.accept = 1;
+#endif
 
 	if (tmp)
 		SSL_CTX_free(tmp);
diff --git a/contrib/socket.h b/contrib/socket.h
index 35cbfc3..ebc9ba1 100644
--- a/contrib/socket.h
+++ b/contrib/socket.h
@@ -179,7 +179,11 @@ struct so_options {
  *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-#define SA_UNIX defined(AF_UNIX) && !_WIN32
+#if defined(AF_UNIX) && !defined(_WIN32)
+#define SA_UNIX 1
+#else
+#define SA_UNIX 0
+#endif
 
 /*
  * GCC 4.4's strong aliasing constraints complain about casting through
diff --git a/regress/20-rr-parse.c b/regress/20-rr-parse.c
new file mode 100644
index 0000000..e43e668
--- /dev/null
+++ b/regress/20-rr-parse.c
@@ -0,0 +1,1143 @@
+/*
+ * Test parsing of modern DNS RR types:
+ * CAA, URI, TLSA, SVCB, HTTPS, DNSKEY, DS, RRSIG, NSEC, NSEC3
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <err.h>
+
+#include "dns.c"
+
+static int test_count = 0;
+static int fail_count = 0;
+
+#define TEST_START(name) do { \
+	test_count++; \
+	fprintf(stderr, "  testing %s... ", name); \
+} while (0)
+
+#define TEST_OK() do { \
+	fprintf(stderr, "OK\n"); \
+} while (0)
+
+#define TEST_FAIL(fmt, ...) do { \
+	fprintf(stderr, "FAILED: " fmt "\n", ##__VA_ARGS__); \
+	fail_count++; \
+} while (0)
+
+/*
+ * Helper to build a minimal DNS packet with one answer RR
+ */
+static struct dns_packet *make_packet(const unsigned char *rdata, size_t rdlen,
+                                       uint16_t type, const char *name) {
+	struct dns_packet *P;
+	unsigned char *p;
+	size_t namelen;
+
+	P = dns_p_make(512, NULL);
+	if (!P)
+		return NULL;
+
+	/* DNS header - 12 bytes */
+	p = P->data;
+	memset(p, 0, 12);
+	p[2] = 0x81; p[3] = 0x80; /* QR=1, RD=1, RA=1 */
+	p[4] = 0x00; p[5] = 0x01; /* QDCOUNT=1 */
+	p[6] = 0x00; p[7] = 0x01; /* ANCOUNT=1 */
+	p += 12;
+
+	/* Question section - encode name */
+	namelen = 0;
+	const char *label = name;
+	while (*label) {
+		const char *dot = strchr(label, '.');
+		size_t llen = dot ? (size_t)(dot - label) : strlen(label);
+		*p++ = (unsigned char)llen;
+		memcpy(p, label, llen);
+		p += llen;
+		namelen += 1 + llen;
+		if (dot)
+			label = dot + 1;
+		else
+			break;
+	}
+	*p++ = 0; /* root label */
+	namelen++;
+
+	/* QTYPE and QCLASS */
+	*p++ = (type >> 8) & 0xff;
+	*p++ = type & 0xff;
+	*p++ = 0x00; *p++ = 0x01; /* IN */
+
+	/* Answer section - use compression pointer to question name */
+	*p++ = 0xc0; *p++ = 0x0c; /* pointer to offset 12 */
+	*p++ = (type >> 8) & 0xff;
+	*p++ = type & 0xff;
+	*p++ = 0x00; *p++ = 0x01; /* IN */
+	*p++ = 0x00; *p++ = 0x00; *p++ = 0x01; *p++ = 0x2c; /* TTL=300 */
+	*p++ = (rdlen >> 8) & 0xff;
+	*p++ = rdlen & 0xff;
+	memcpy(p, rdata, rdlen);
+	p += rdlen;
+
+	P->end = p - P->data;
+
+	return P;
+}
+
+/*
+ * Test CAA record parsing
+ * RFC 8659: flags (1) + tag-length (1) + tag + value
+ */
+static void test_caa(void) {
+	TEST_START("CAA basic");
+
+	/* CAA 0 issue "pki.goog" */
+	unsigned char rdata[] = {
+		0x00,                   /* flags = 0 */
+		0x05,                   /* tag length = 5 */
+		'i', 's', 's', 'u', 'e', /* tag = "issue" */
+		'p', 'k', 'i', '.', 'g', 'o', 'o', 'g' /* value = "pki.goog" */
+	};
+
+	struct dns_packet *P = make_packet(rdata, sizeof(rdata), DNS_T_CAA, "example.com");
+	if (!P) { TEST_FAIL("make_packet"); return; }
+
+	struct dns_rr rr;
+	struct dns_rr_i *I = dns_rr_i_new(P, .section = DNS_S_AN);
+	int error;
+
+	if (!dns_rr_grep(&rr, 1, I, P, &error)) {
+		TEST_FAIL("dns_rr_grep: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	union dns_any any;
+	dns_any_init(&any, sizeof(any));
+	error = dns_any_parse(&any, &rr, P);
+	if (error) {
+		TEST_FAIL("dns_any_parse: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	if (any.caa.flags != 0) {
+		TEST_FAIL("flags: expected 0, got %d", any.caa.flags);
+		free(P);
+		return;
+	}
+	if (strcmp(any.caa.tag, "issue") != 0) {
+		TEST_FAIL("tag: expected 'issue', got '%s'", any.caa.tag);
+		free(P);
+		return;
+	}
+	if (strcmp((const char *)any.caa.value, "pki.goog") != 0) {
+		TEST_FAIL("value: expected 'pki.goog', got '%s'", any.caa.value);
+		free(P);
+		return;
+	}
+
+	/* Test print */
+	char buf[256];
+	dns_caa_print(buf, sizeof(buf), &any.caa);
+	if (strstr(buf, "issue") == NULL || strstr(buf, "pki.goog") == NULL) {
+		TEST_FAIL("print: '%s'", buf);
+		free(P);
+		return;
+	}
+
+	free(P);
+	TEST_OK();
+}
+
+static void test_caa_critical(void) {
+	TEST_START("CAA critical flag");
+
+	/* CAA 128 issuewild ";" */
+	unsigned char rdata[] = {
+		0x80,                         /* flags = 128 (critical) */
+		0x09,                         /* tag length = 9 */
+		'i', 's', 's', 'u', 'e', 'w', 'i', 'l', 'd',
+		';'                           /* value = ";" */
+	};
+
+	struct dns_packet *P = make_packet(rdata, sizeof(rdata), DNS_T_CAA, "example.com");
+	if (!P) { TEST_FAIL("make_packet"); return; }
+
+	struct dns_rr rr;
+	struct dns_rr_i *I = dns_rr_i_new(P, .section = DNS_S_AN);
+	int error;
+
+	if (!dns_rr_grep(&rr, 1, I, P, &error)) {
+		TEST_FAIL("dns_rr_grep: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	union dns_any any;
+	dns_any_init(&any, sizeof(any));
+	error = dns_any_parse(&any, &rr, P);
+	if (error) {
+		TEST_FAIL("dns_any_parse: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	if (any.caa.flags != 128) {
+		TEST_FAIL("flags: expected 128, got %d", any.caa.flags);
+		free(P);
+		return;
+	}
+	if (strcmp(any.caa.tag, "issuewild") != 0) {
+		TEST_FAIL("tag: expected 'issuewild', got '%s'", any.caa.tag);
+		free(P);
+		return;
+	}
+
+	free(P);
+	TEST_OK();
+}
+
+/*
+ * Test URI record parsing
+ * RFC 7553: priority (2) + weight (2) + target
+ */
+static void test_uri(void) {
+	TEST_START("URI basic");
+
+	/* URI 10 1 "ftp://ftp.example.com/public" */
+	unsigned char rdata[] = {
+		0x00, 0x0a,             /* priority = 10 */
+		0x00, 0x01,             /* weight = 1 */
+		'f', 't', 'p', ':', '/', '/', 'f', 't', 'p', '.',
+		'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm',
+		'/', 'p', 'u', 'b', 'l', 'i', 'c'
+	};
+
+	struct dns_packet *P = make_packet(rdata, sizeof(rdata), DNS_T_URI, "_ftp._tcp.example.com");
+	if (!P) { TEST_FAIL("make_packet"); return; }
+
+	struct dns_rr rr;
+	struct dns_rr_i *I = dns_rr_i_new(P, .section = DNS_S_AN);
+	int error;
+
+	if (!dns_rr_grep(&rr, 1, I, P, &error)) {
+		TEST_FAIL("dns_rr_grep: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	union dns_any any;
+	dns_any_init(&any, sizeof(any));
+	error = dns_any_parse(&any, &rr, P);
+	if (error) {
+		TEST_FAIL("dns_any_parse: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	if (any.uri.priority != 10) {
+		TEST_FAIL("priority: expected 10, got %d", any.uri.priority);
+		free(P);
+		return;
+	}
+	if (any.uri.weight != 1) {
+		TEST_FAIL("weight: expected 1, got %d", any.uri.weight);
+		free(P);
+		return;
+	}
+	if (strcmp(any.uri.target, "ftp://ftp.example.com/public") != 0) {
+		TEST_FAIL("target: expected 'ftp://ftp.example.com/public', got '%s'", any.uri.target);
+		free(P);
+		return;
+	}
+
+	free(P);
+	TEST_OK();
+}
+
+/*
+ * Test TLSA record parsing
+ * RFC 6698: usage (1) + selector (1) + matching-type (1) + certificate-data
+ */
+static void test_tlsa(void) {
+	TEST_START("TLSA basic");
+
+	/* TLSA 3 1 1 <sha256-hash> */
+	unsigned char rdata[] = {
+		0x03,                   /* usage = 3 (DANE-EE) */
+		0x01,                   /* selector = 1 (SubjectPublicKeyInfo) */
+		0x01,                   /* matching type = 1 (SHA-256) */
+		/* 32-byte SHA-256 hash */
+		0x38, 0xa8, 0x81, 0x26, 0xa1, 0x5a, 0xe8, 0xe6,
+		0x43, 0xce, 0x94, 0x47, 0xc3, 0xce, 0x9a, 0x87,
+		0x4e, 0xa0, 0xe0, 0x52, 0x55, 0xd0, 0x7e, 0xe1,
+		0x22, 0x27, 0x80, 0x9e, 0xdb, 0xe5, 0xc7, 0xf1
+	};
+
+	struct dns_packet *P = make_packet(rdata, sizeof(rdata), DNS_T_TLSA, "_25._tcp.mail.example.org");
+	if (!P) { TEST_FAIL("make_packet"); return; }
+
+	struct dns_rr rr;
+	struct dns_rr_i *I = dns_rr_i_new(P, .section = DNS_S_AN);
+	int error;
+
+	if (!dns_rr_grep(&rr, 1, I, P, &error)) {
+		TEST_FAIL("dns_rr_grep: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	union dns_any any;
+	dns_any_init(&any, sizeof(any));
+	error = dns_any_parse(&any, &rr, P);
+	if (error) {
+		TEST_FAIL("dns_any_parse: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	if (any.tlsa.usage != 3) {
+		TEST_FAIL("usage: expected 3, got %d", any.tlsa.usage);
+		free(P);
+		return;
+	}
+	if (any.tlsa.selector != 1) {
+		TEST_FAIL("selector: expected 1, got %d", any.tlsa.selector);
+		free(P);
+		return;
+	}
+	if (any.tlsa.matchtype != 1) {
+		TEST_FAIL("matchtype: expected 1, got %d", any.tlsa.matchtype);
+		free(P);
+		return;
+	}
+	if (any.tlsa.datalen != 32) {
+		TEST_FAIL("datalen: expected 32, got %zu", any.tlsa.datalen);
+		free(P);
+		return;
+	}
+	if (memcmp(any.tlsa.data, rdata + 3, 32) != 0) {
+		TEST_FAIL("data mismatch");
+		free(P);
+		return;
+	}
+
+	/* Test print output */
+	char buf[256];
+	dns_tlsa_print(buf, sizeof(buf), &any.tlsa);
+	if (strstr(buf, "3 1 1") == NULL) {
+		TEST_FAIL("print missing '3 1 1': '%s'", buf);
+		free(P);
+		return;
+	}
+
+	free(P);
+	TEST_OK();
+}
+
+/*
+ * Test SVCB/HTTPS record parsing
+ * RFC 9460: priority (2) + target (wire format) + SvcParams
+ */
+static void test_svcb(void) {
+	TEST_START("SVCB basic");
+
+	/* SVCB 1 . alpn=h2 */
+	unsigned char rdata[] = {
+		0x00, 0x01,             /* priority = 1 */
+		0x00,                   /* target = "." (root) */
+		0x00, 0x01,             /* key = alpn (1) */
+		0x00, 0x03,             /* length = 3 */
+		0x02, 'h', '2'          /* alpn-id = "h2" */
+	};
+
+	struct dns_packet *P = make_packet(rdata, sizeof(rdata), DNS_T_SVCB, "_https._tcp.example.com");
+	if (!P) { TEST_FAIL("make_packet"); return; }
+
+	struct dns_rr rr;
+	struct dns_rr_i *I = dns_rr_i_new(P, .section = DNS_S_AN);
+	int error;
+
+	if (!dns_rr_grep(&rr, 1, I, P, &error)) {
+		TEST_FAIL("dns_rr_grep: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	union dns_any any;
+	dns_any_init(&any, sizeof(any));
+	error = dns_any_parse(&any, &rr, P);
+	if (error) {
+		TEST_FAIL("dns_any_parse: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	if (any.svcb.priority != 1) {
+		TEST_FAIL("priority: expected 1, got %d", any.svcb.priority);
+		free(P);
+		return;
+	}
+	/* Target "." becomes empty string after expansion */
+	if (any.svcb.target[0] != '\0' && strcmp(any.svcb.target, ".") != 0) {
+		TEST_FAIL("target: expected '' or '.', got '%s'", any.svcb.target);
+		free(P);
+		return;
+	}
+	if (any.svcb.paramslen != 7) {
+		TEST_FAIL("paramslen: expected 7, got %zu", any.svcb.paramslen);
+		free(P);
+		return;
+	}
+
+	/* Test print */
+	char buf[256];
+	dns_svcb_print(buf, sizeof(buf), &any.svcb);
+	if (strstr(buf, "alpn=") == NULL || strstr(buf, "h2") == NULL) {
+		TEST_FAIL("print missing alpn: '%s'", buf);
+		free(P);
+		return;
+	}
+
+	free(P);
+	TEST_OK();
+}
+
+static void test_https(void) {
+	TEST_START("HTTPS with ipv4hint");
+
+	/* HTTPS 1 . alpn=h3,h2 ipv4hint=104.16.123.96,104.16.124.96 */
+	unsigned char rdata[] = {
+		0x00, 0x01,             /* priority = 1 */
+		0x00,                   /* target = "." */
+		0x00, 0x01, 0x00, 0x06, /* key=alpn, len=6 */
+		0x02, 'h', '3', 0x02, 'h', '2',
+		0x00, 0x04, 0x00, 0x08, /* key=ipv4hint, len=8 */
+		0x68, 0x10, 0x7b, 0x60, /* 104.16.123.96 */
+		0x68, 0x10, 0x7c, 0x60  /* 104.16.124.96 */
+	};
+
+	struct dns_packet *P = make_packet(rdata, sizeof(rdata), DNS_T_HTTPS, "www.cloudflare.com");
+	if (!P) { TEST_FAIL("make_packet"); return; }
+
+	struct dns_rr rr;
+	struct dns_rr_i *I = dns_rr_i_new(P, .section = DNS_S_AN);
+	int error;
+
+	if (!dns_rr_grep(&rr, 1, I, P, &error)) {
+		TEST_FAIL("dns_rr_grep: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	union dns_any any;
+	dns_any_init(&any, sizeof(any));
+	error = dns_any_parse(&any, &rr, P);
+	if (error) {
+		TEST_FAIL("dns_any_parse: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	if (any.https.priority != 1) {
+		TEST_FAIL("priority: expected 1, got %d", any.https.priority);
+		free(P);
+		return;
+	}
+
+	/* Test print */
+	char buf[512];
+	dns_svcb_print(buf, sizeof(buf), &any.https);
+	if (strstr(buf, "104.16.123.96") == NULL) {
+		TEST_FAIL("print missing ipv4hint: '%s'", buf);
+		free(P);
+		return;
+	}
+	if (strstr(buf, "h3") == NULL) {
+		TEST_FAIL("print missing h3: '%s'", buf);
+		free(P);
+		return;
+	}
+
+	free(P);
+	TEST_OK();
+}
+
+static void test_https_ipv6(void) {
+	TEST_START("HTTPS with ipv6hint");
+
+	/* HTTPS 1 . ipv6hint=2606:4700::6810:7b60 */
+	unsigned char rdata[] = {
+		0x00, 0x01,             /* priority = 1 */
+		0x00,                   /* target = "." */
+		0x00, 0x06, 0x00, 0x10, /* key=ipv6hint, len=16 */
+		0x26, 0x06, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x68, 0x10, 0x7b, 0x60
+	};
+
+	struct dns_packet *P = make_packet(rdata, sizeof(rdata), DNS_T_HTTPS, "example.com");
+	if (!P) { TEST_FAIL("make_packet"); return; }
+
+	struct dns_rr rr;
+	struct dns_rr_i *I = dns_rr_i_new(P, .section = DNS_S_AN);
+	int error;
+
+	if (!dns_rr_grep(&rr, 1, I, P, &error)) {
+		TEST_FAIL("dns_rr_grep: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	union dns_any any;
+	dns_any_init(&any, sizeof(any));
+	error = dns_any_parse(&any, &rr, P);
+	if (error) {
+		TEST_FAIL("dns_any_parse: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	/* Test print */
+	char buf[512];
+	dns_svcb_print(buf, sizeof(buf), &any.https);
+	if (strstr(buf, "2606:4700") == NULL) {
+		TEST_FAIL("print missing ipv6: '%s'", buf);
+		free(P);
+		return;
+	}
+
+	free(P);
+	TEST_OK();
+}
+
+static void test_svcb_aliasmode(void) {
+	TEST_START("SVCB AliasMode (priority=0)");
+
+	/* SVCB 0 pool.svc.example. (AliasMode) */
+	unsigned char rdata[] = {
+		0x00, 0x00,             /* priority = 0 (AliasMode) */
+		0x04, 'p', 'o', 'o', 'l',
+		0x03, 's', 'v', 'c',
+		0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
+		0x00
+	};
+
+	struct dns_packet *P = make_packet(rdata, sizeof(rdata), DNS_T_SVCB, "example.com");
+	if (!P) { TEST_FAIL("make_packet"); return; }
+
+	struct dns_rr rr;
+	struct dns_rr_i *I = dns_rr_i_new(P, .section = DNS_S_AN);
+	int error;
+
+	if (!dns_rr_grep(&rr, 1, I, P, &error)) {
+		TEST_FAIL("dns_rr_grep: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	union dns_any any;
+	dns_any_init(&any, sizeof(any));
+	error = dns_any_parse(&any, &rr, P);
+	if (error) {
+		TEST_FAIL("dns_any_parse: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	if (any.svcb.priority != 0) {
+		TEST_FAIL("priority: expected 0, got %d", any.svcb.priority);
+		free(P);
+		return;
+	}
+	if (strstr(any.svcb.target, "pool.svc.example") == NULL) {
+		TEST_FAIL("target: expected 'pool.svc.example', got '%s'", any.svcb.target);
+		free(P);
+		return;
+	}
+
+	free(P);
+	TEST_OK();
+}
+
+/*
+ * Test DNSKEY record parsing
+ * RFC 4034: flags (2) + protocol (1) + algorithm (1) + public-key
+ */
+static void test_dnskey(void) {
+	TEST_START("DNSKEY KSK");
+
+	/* DNSKEY 257 3 13 <base64-key> - 257 = KSK */
+	unsigned char rdata[] = {
+		0x01, 0x01,             /* flags = 257 (KSK) */
+		0x03,                   /* protocol = 3 */
+		0x0d,                   /* algorithm = 13 (ECDSAP256SHA256) */
+		/* 64-byte ECDSA P-256 public key */
+		0x99, 0xdb, 0x30, 0xc1, 0x4b, 0xab, 0xdc, 0x33,
+		0xd6, 0xdf, 0x66, 0x3a, 0x2e, 0x15, 0xf7, 0x12,
+		0x58, 0x4f, 0x09, 0x8e, 0x8d, 0x4e, 0x8d, 0x1d,
+		0xc4, 0x28, 0xe3, 0x9a, 0x8a, 0x49, 0x97, 0xe1,
+		0xaa, 0x27, 0x1a, 0x55, 0x5d, 0xc9, 0x07, 0x01,
+		0xe1, 0x7e, 0x2a, 0x4c, 0x4b, 0x6f, 0x12, 0x0b,
+		0x7c, 0x35, 0xd4, 0x4f, 0x4a, 0xc0, 0x2b, 0xd8,
+		0x94, 0xef, 0x32, 0xeb, 0x9d, 0xb6, 0x5e, 0x19
+	};
+
+	struct dns_packet *P = make_packet(rdata, sizeof(rdata), DNS_T_DNSKEY, "cloudflare.com");
+	if (!P) { TEST_FAIL("make_packet"); return; }
+
+	struct dns_rr rr;
+	struct dns_rr_i *I = dns_rr_i_new(P, .section = DNS_S_AN);
+	int error;
+
+	if (!dns_rr_grep(&rr, 1, I, P, &error)) {
+		TEST_FAIL("dns_rr_grep: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	union dns_any any;
+	dns_any_init(&any, sizeof(any));
+	error = dns_any_parse(&any, &rr, P);
+	if (error) {
+		TEST_FAIL("dns_any_parse: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	if (any.dnskey.flags != 257) {
+		TEST_FAIL("flags: expected 257, got %d", any.dnskey.flags);
+		free(P);
+		return;
+	}
+	if (any.dnskey.protocol != 3) {
+		TEST_FAIL("protocol: expected 3, got %d", any.dnskey.protocol);
+		free(P);
+		return;
+	}
+	if (any.dnskey.algorithm != 13) {
+		TEST_FAIL("algorithm: expected 13, got %d", any.dnskey.algorithm);
+		free(P);
+		return;
+	}
+	if (any.dnskey.pubkeylen != 64) {
+		TEST_FAIL("pubkeylen: expected 64, got %zu", any.dnskey.pubkeylen);
+		free(P);
+		return;
+	}
+
+	/* Test print - should contain base64 key */
+	char buf[512];
+	dns_dnskey_print(buf, sizeof(buf), &any.dnskey);
+	if (strstr(buf, "257 3 13") == NULL) {
+		TEST_FAIL("print missing '257 3 13': '%s'", buf);
+		free(P);
+		return;
+	}
+
+	free(P);
+	TEST_OK();
+}
+
+static void test_dnskey_zsk(void) {
+	TEST_START("DNSKEY ZSK");
+
+	/* DNSKEY 256 3 13 <key> - 256 = ZSK */
+	unsigned char rdata[] = {
+		0x01, 0x00,             /* flags = 256 (ZSK) */
+		0x03,                   /* protocol = 3 */
+		0x0d,                   /* algorithm = 13 */
+		/* 64-byte key */
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
+	};
+
+	struct dns_packet *P = make_packet(rdata, sizeof(rdata), DNS_T_DNSKEY, "example.com");
+	if (!P) { TEST_FAIL("make_packet"); return; }
+
+	struct dns_rr rr;
+	struct dns_rr_i *I = dns_rr_i_new(P, .section = DNS_S_AN);
+	int error;
+
+	if (!dns_rr_grep(&rr, 1, I, P, &error)) {
+		TEST_FAIL("dns_rr_grep: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	union dns_any any;
+	dns_any_init(&any, sizeof(any));
+	error = dns_any_parse(&any, &rr, P);
+	if (error) {
+		TEST_FAIL("dns_any_parse: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	if (any.dnskey.flags != 256) {
+		TEST_FAIL("flags: expected 256, got %d", any.dnskey.flags);
+		free(P);
+		return;
+	}
+
+	free(P);
+	TEST_OK();
+}
+
+/*
+ * Test DS record parsing
+ * RFC 4034: keytag (2) + algorithm (1) + digest-type (1) + digest
+ */
+static void test_ds(void) {
+	TEST_START("DS SHA-256");
+
+	/* DS 2371 13 2 <sha256-digest> */
+	unsigned char rdata[] = {
+		0x09, 0x43,             /* keytag = 2371 */
+		0x0d,                   /* algorithm = 13 (ECDSAP256SHA256) */
+		0x02,                   /* digest type = 2 (SHA-256) */
+		/* 32-byte SHA-256 digest */
+		0x32, 0x99, 0x68, 0x39, 0xa6, 0xd8, 0x08, 0xaf,
+		0xe3, 0xeb, 0x4a, 0x79, 0x5a, 0x0e, 0x6a, 0x7a,
+		0x39, 0xa7, 0x6f, 0xc5, 0x2f, 0xf2, 0x28, 0xb2,
+		0x2b, 0x76, 0xf6, 0xd6, 0x38, 0x26, 0xf2, 0xb9
+	};
+
+	struct dns_packet *P = make_packet(rdata, sizeof(rdata), DNS_T_DS, "cloudflare.com");
+	if (!P) { TEST_FAIL("make_packet"); return; }
+
+	struct dns_rr rr;
+	struct dns_rr_i *I = dns_rr_i_new(P, .section = DNS_S_AN);
+	int error;
+
+	if (!dns_rr_grep(&rr, 1, I, P, &error)) {
+		TEST_FAIL("dns_rr_grep: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	union dns_any any;
+	dns_any_init(&any, sizeof(any));
+	error = dns_any_parse(&any, &rr, P);
+	if (error) {
+		TEST_FAIL("dns_any_parse: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	if (any.ds.keytag != 2371) {
+		TEST_FAIL("keytag: expected 2371, got %d", any.ds.keytag);
+		free(P);
+		return;
+	}
+	if (any.ds.algorithm != 13) {
+		TEST_FAIL("algorithm: expected 13, got %d", any.ds.algorithm);
+		free(P);
+		return;
+	}
+	if (any.ds.digtype != 2) {
+		TEST_FAIL("digtype: expected 2, got %d", any.ds.digtype);
+		free(P);
+		return;
+	}
+	if (any.ds.digestlen != 32) {
+		TEST_FAIL("digestlen: expected 32, got %zu", any.ds.digestlen);
+		free(P);
+		return;
+	}
+
+	/* Test print */
+	char buf[256];
+	dns_ds_print(buf, sizeof(buf), &any.ds);
+	if (strstr(buf, "2371 13 2") == NULL) {
+		TEST_FAIL("print missing '2371 13 2': '%s'", buf);
+		free(P);
+		return;
+	}
+
+	free(P);
+	TEST_OK();
+}
+
+/*
+ * Test RRSIG record parsing
+ * RFC 4034: type-covered (2) + algorithm (1) + labels (1) + original-ttl (4)
+ *           + expiration (4) + inception (4) + keytag (2) + signer + signature
+ */
+static void test_rrsig(void) {
+	TEST_START("RRSIG basic");
+
+	/* RRSIG A 13 2 300 20251231235959 20251201000000 12345 example.com. <sig> */
+	unsigned char rdata[] = {
+		0x00, 0x01,             /* type covered = A (1) */
+		0x0d,                   /* algorithm = 13 */
+		0x02,                   /* labels = 2 */
+		0x00, 0x00, 0x01, 0x2c, /* original TTL = 300 */
+		0x67, 0x74, 0x42, 0xef, /* expiration = 20251231235959 (approx timestamp) */
+		0x67, 0x4b, 0xfe, 0x80, /* inception = 20251201000000 (approx timestamp) */
+		0x30, 0x39,             /* keytag = 12345 */
+		/* signer name: example.com */
+		0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
+		0x03, 'c', 'o', 'm',
+		0x00,
+		/* signature (64 bytes for ECDSA P-256) */
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
+	};
+
+	struct dns_packet *P = make_packet(rdata, sizeof(rdata), DNS_T_RRSIG, "example.com");
+	if (!P) { TEST_FAIL("make_packet"); return; }
+
+	struct dns_rr rr;
+	struct dns_rr_i *I = dns_rr_i_new(P, .section = DNS_S_AN);
+	int error;
+
+	if (!dns_rr_grep(&rr, 1, I, P, &error)) {
+		TEST_FAIL("dns_rr_grep: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	union dns_any any;
+	dns_any_init(&any, sizeof(any));
+	error = dns_any_parse(&any, &rr, P);
+	if (error) {
+		TEST_FAIL("dns_any_parse: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	if (any.rrsig.covered != DNS_T_A) {
+		TEST_FAIL("covered: expected %d, got %d", DNS_T_A, any.rrsig.covered);
+		free(P);
+		return;
+	}
+	if (any.rrsig.algorithm != 13) {
+		TEST_FAIL("algorithm: expected 13, got %d", any.rrsig.algorithm);
+		free(P);
+		return;
+	}
+	if (any.rrsig.labels != 2) {
+		TEST_FAIL("labels: expected 2, got %d", any.rrsig.labels);
+		free(P);
+		return;
+	}
+	if (any.rrsig.origttl != 300) {
+		TEST_FAIL("origttl: expected 300, got %u", any.rrsig.origttl);
+		free(P);
+		return;
+	}
+	if (any.rrsig.keytag != 12345) {
+		TEST_FAIL("keytag: expected 12345, got %d", any.rrsig.keytag);
+		free(P);
+		return;
+	}
+	if (strstr(any.rrsig.signer, "example.com") == NULL) {
+		TEST_FAIL("signer: expected 'example.com', got '%s'", any.rrsig.signer);
+		free(P);
+		return;
+	}
+	if (any.rrsig.siglen != 64) {
+		TEST_FAIL("siglen: expected 64, got %zu", any.rrsig.siglen);
+		free(P);
+		return;
+	}
+
+	/* Test print */
+	char buf[512];
+	dns_rrsig_print(buf, sizeof(buf), &any.rrsig);
+	if (strstr(buf, "A 13 2 300") == NULL) {
+		TEST_FAIL("print missing 'A 13 2 300': '%s'", buf);
+		free(P);
+		return;
+	}
+
+	free(P);
+	TEST_OK();
+}
+
+/*
+ * Test NSEC record parsing
+ * RFC 4034: next-domain-name + type-bit-maps
+ */
+static void test_nsec(void) {
+	TEST_START("NSEC basic");
+
+	/* NSEC beta.example.com. A NS SOA MX RRSIG NSEC */
+	unsigned char rdata[] = {
+		/* next domain: beta.example.com */
+		0x04, 'b', 'e', 't', 'a',
+		0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
+		0x03, 'c', 'o', 'm',
+		0x00,
+		/* type bitmap: window 0, length 7 */
+		0x00,                   /* window block 0 */
+		0x07,                   /* bitmap length = 7 */
+		/* bits: A(1), NS(2), SOA(6), MX(15), RRSIG(46), NSEC(47) */
+		/* byte 0: types 0-7:   00000110 = 0x06 (bits 1,2 = A,NS) - but bit 0 is type 0 */
+		/* Actually: bit 0 = type 0, bit 1 = type 1 (A), bit 2 = type 2 (NS) */
+		/* So for A(1), NS(2): byte 0 bits 1,2 set = 0x60 (big-endian bit order) */
+		0x62,                   /* A(1), NS(2), SOA(6): bits 1,2,6 in BE order */
+		0x00,                   /* types 8-15: MX is type 15 */
+		0x01,                   /* MX (15) - bit 7 of this byte */
+		0x00, 0x00, 0x00,       /* types 16-39 */
+		0x03                    /* types 40-47: RRSIG(46), NSEC(47) - bits 6,7 */
+	};
+
+	struct dns_packet *P = make_packet(rdata, sizeof(rdata), DNS_T_NSEC, "alpha.example.com");
+	if (!P) { TEST_FAIL("make_packet"); return; }
+
+	struct dns_rr rr;
+	struct dns_rr_i *I = dns_rr_i_new(P, .section = DNS_S_AN);
+	int error;
+
+	if (!dns_rr_grep(&rr, 1, I, P, &error)) {
+		TEST_FAIL("dns_rr_grep: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	union dns_any any;
+	dns_any_init(&any, sizeof(any));
+	error = dns_any_parse(&any, &rr, P);
+	if (error) {
+		TEST_FAIL("dns_any_parse: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	if (strstr(any.nsec.next, "beta.example.com") == NULL) {
+		TEST_FAIL("next: expected 'beta.example.com', got '%s'", any.nsec.next);
+		free(P);
+		return;
+	}
+	if (any.nsec.typemaplen != 9) {
+		TEST_FAIL("typemaplen: expected 9, got %zu", any.nsec.typemaplen);
+		free(P);
+		return;
+	}
+
+	/* Test print */
+	char buf[512];
+	dns_nsec_print(buf, sizeof(buf), &any.nsec);
+	if (strstr(buf, "beta.example.com") == NULL) {
+		TEST_FAIL("print missing next domain: '%s'", buf);
+		free(P);
+		return;
+	}
+
+	free(P);
+	TEST_OK();
+}
+
+/*
+ * Test NSEC3 record parsing
+ * RFC 5155: algorithm + flags + iterations + salt-len + salt + hash-len + hash + type-bitmaps
+ */
+static void test_nsec3(void) {
+	TEST_START("NSEC3 basic");
+
+	/* NSEC3 1 0 10 aabbccdd <base32-hash> A NS SOA */
+	unsigned char rdata[] = {
+		0x01,                   /* hash algorithm = 1 (SHA-1) */
+		0x00,                   /* flags = 0 */
+		0x00, 0x0a,             /* iterations = 10 */
+		0x04,                   /* salt length = 4 */
+		0xaa, 0xbb, 0xcc, 0xdd, /* salt */
+		0x14,                   /* hash length = 20 (SHA-1) */
+		/* 20-byte SHA-1 hash */
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+		0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+		0x11, 0x12, 0x13, 0x14,
+		/* type bitmap: window 0, length 1 */
+		0x00,                   /* window 0 */
+		0x01,                   /* bitmap length = 1 */
+		0x62                    /* A(1), NS(2), SOA(6) */
+	};
+
+	struct dns_packet *P = make_packet(rdata, sizeof(rdata), DNS_T_NSEC3, "example.com");
+	if (!P) { TEST_FAIL("make_packet"); return; }
+
+	struct dns_rr rr;
+	struct dns_rr_i *I = dns_rr_i_new(P, .section = DNS_S_AN);
+	int error;
+
+	if (!dns_rr_grep(&rr, 1, I, P, &error)) {
+		TEST_FAIL("dns_rr_grep: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	union dns_any any;
+	dns_any_init(&any, sizeof(any));
+	error = dns_any_parse(&any, &rr, P);
+	if (error) {
+		TEST_FAIL("dns_any_parse: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	if (any.nsec3.algorithm != 1) {
+		TEST_FAIL("algorithm: expected 1, got %d", any.nsec3.algorithm);
+		free(P);
+		return;
+	}
+	if (any.nsec3.flags != 0) {
+		TEST_FAIL("flags: expected 0, got %d", any.nsec3.flags);
+		free(P);
+		return;
+	}
+	if (any.nsec3.iterations != 10) {
+		TEST_FAIL("iterations: expected 10, got %d", any.nsec3.iterations);
+		free(P);
+		return;
+	}
+	if (any.nsec3.saltlen != 4) {
+		TEST_FAIL("saltlen: expected 4, got %zu", any.nsec3.saltlen);
+		free(P);
+		return;
+	}
+	if (any.nsec3.nexthashlen != 20) {
+		TEST_FAIL("nexthashlen: expected 20, got %zu", any.nsec3.nexthashlen);
+		free(P);
+		return;
+	}
+
+	/* Test print */
+	char buf[512];
+	dns_nsec3_print(buf, sizeof(buf), &any.nsec3);
+	if (strstr(buf, "1 0 10") == NULL) {
+		TEST_FAIL("print missing '1 0 10': '%s'", buf);
+		free(P);
+		return;
+	}
+
+	free(P);
+	TEST_OK();
+}
+
+static void test_nsec3_nosalt(void) {
+	TEST_START("NSEC3 no salt");
+
+	/* NSEC3 1 1 0 - <hash> A */
+	unsigned char rdata[] = {
+		0x01,                   /* algorithm = 1 */
+		0x01,                   /* flags = 1 (opt-out) */
+		0x00, 0x00,             /* iterations = 0 */
+		0x00,                   /* salt length = 0 (no salt) */
+		0x14,                   /* hash length = 20 */
+		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+		0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+		0x11, 0x12, 0x13, 0x14,
+		/* type bitmap */
+		0x00, 0x01, 0x40        /* A(1) */
+	};
+
+	struct dns_packet *P = make_packet(rdata, sizeof(rdata), DNS_T_NSEC3, "example.com");
+	if (!P) { TEST_FAIL("make_packet"); return; }
+
+	struct dns_rr rr;
+	struct dns_rr_i *I = dns_rr_i_new(P, .section = DNS_S_AN);
+	int error;
+
+	if (!dns_rr_grep(&rr, 1, I, P, &error)) {
+		TEST_FAIL("dns_rr_grep: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	union dns_any any;
+	dns_any_init(&any, sizeof(any));
+	error = dns_any_parse(&any, &rr, P);
+	if (error) {
+		TEST_FAIL("dns_any_parse: %s", dns_strerror(error));
+		free(P);
+		return;
+	}
+
+	if (any.nsec3.saltlen != 0) {
+		TEST_FAIL("saltlen: expected 0, got %zu", any.nsec3.saltlen);
+		free(P);
+		return;
+	}
+	if (any.nsec3.flags != 1) {
+		TEST_FAIL("flags: expected 1, got %d", any.nsec3.flags);
+		free(P);
+		return;
+	}
+
+	free(P);
+	TEST_OK();
+}
+
+int main(void) {
+	fprintf(stderr, "Testing RR type parsing:\n");
+
+	/* CAA tests */
+	fprintf(stderr, "\nCAA:\n");
+	test_caa();
+	test_caa_critical();
+
+	/* URI tests */
+	fprintf(stderr, "\nURI:\n");
+	test_uri();
+
+	/* TLSA tests */
+	fprintf(stderr, "\nTLSA:\n");
+	test_tlsa();
+
+	/* SVCB/HTTPS tests */
+	fprintf(stderr, "\nSVCB/HTTPS:\n");
+	test_svcb();
+	test_https();
+	test_https_ipv6();
+	test_svcb_aliasmode();
+
+	/* DNSKEY tests */
+	fprintf(stderr, "\nDNSKEY:\n");
+	test_dnskey();
+	test_dnskey_zsk();
+
+	/* DS tests */
+	fprintf(stderr, "\nDS:\n");
+	test_ds();
+
+	/* RRSIG tests */
+	fprintf(stderr, "\nRRSIG:\n");
+	test_rrsig();
+
+	/* NSEC tests */
+	fprintf(stderr, "\nNSEC:\n");
+	test_nsec();
+
+	/* NSEC3 tests */
+	fprintf(stderr, "\nNSEC3:\n");
+	test_nsec3();
+	test_nsec3_nosalt();
+
+	fprintf(stderr, "\n--------------------\n");
+	fprintf(stderr, "Tests: %d, Failures: %d\n", test_count, fail_count);
+
+	if (fail_count > 0) {
+		fprintf(stderr, "FAILED\n");
+		return 1;
+	}
+
+	fprintf(stderr, "ALL TESTS PASSED\n");
+	return 0;
+}
diff --git a/regress/Makefile b/regress/Makefile
index 3f80543..c9af2d6 100644
--- a/regress/Makefile
+++ b/regress/Makefile
@@ -8,24 +8,34 @@ LDFLAGS += -L/usr/local/libyaml/lib
 rfc4408-tests: rfc4408-tests.c ../src/cache.c ../src/zone.c ../src/spf.c ../src/dns.c
 	$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) -o $@ $^ -lyaml $(LIBS)
 
-%.c: %.rl
+../src/%.c: ../src/%.rl
 	ragel -C -o $@ $<
 
-TESTS = \
+# Tests that link with dns.c
+TESTS_LINK = \
 	00-spf_xtoi \
 	12-segfault-in-dns_res_frame_init \
 	14-dns_resconf_search-fqdn \
 	15-dns_ai_nextaf-null-deref
 
+# Tests that include dns.c directly (for access to static functions)
+TESTS_INCLUDE = \
+	20-rr-parse
+
+TESTS = ${TESTS_LINK} ${TESTS_INCLUDE}
+
 00-spf_xtoi: 00-spf_xtoi.c ../src/spf.c
 12-segfault-in-dns_res_frame_init: 12-segfault-in-dns_res_frame_init.c
 14-dns_resconf_search-fqdn: 14-dns_resconf_search-fqdn.c
 15-dns_ai_nextaf-null-deref: 15-dns_ai_nextaf-null-deref.c
 
-${TESTS}: ../src/dns.c
-${TESTS}:
+${TESTS_LINK}: ../src/dns.c
+${TESTS_LINK}:
 	$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) -o $@ $@.c ../src/dns.c $(LIBS)
 
+20-rr-parse: 20-rr-parse.c ../src/dns.c
+	$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) -o $@ $< $(LIBS)
+
 tests: ${TESTS}
 
 check: ${TESTS}
diff --git a/regress/corpus/004d5b4467bd281005176ed98bdc736f2dadb4b7 b/regress/corpus/004d5b4467bd281005176ed98bdc736f2dadb4b7
new file mode 100644
index 0000000..32ae13b
Binary files /dev/null and b/regress/corpus/004d5b4467bd281005176ed98bdc736f2dadb4b7 differ
diff --git a/regress/corpus/005503625130125d714578a5d87b175b4539d89c b/regress/corpus/005503625130125d714578a5d87b175b4539d89c
new file mode 100644
index 0000000..c1519bf
Binary files /dev/null and b/regress/corpus/005503625130125d714578a5d87b175b4539d89c differ
diff --git a/regress/corpus/006b7ed96a226ecdbc7b112c4de4093feda16971 b/regress/corpus/006b7ed96a226ecdbc7b112c4de4093feda16971
new file mode 100644
index 0000000..d350e0f
Binary files /dev/null and b/regress/corpus/006b7ed96a226ecdbc7b112c4de4093feda16971 differ
diff --git a/regress/corpus/00750186b3a1527973c9dd3eaeef58d562d5dfb3 b/regress/corpus/00750186b3a1527973c9dd3eaeef58d562d5dfb3
new file mode 100644
index 0000000..da655ef
Binary files /dev/null and b/regress/corpus/00750186b3a1527973c9dd3eaeef58d562d5dfb3 differ
diff --git a/regress/corpus/007759a3d0ad4770ac6735cbfbe2b283c84db9a8 b/regress/corpus/007759a3d0ad4770ac6735cbfbe2b283c84db9a8
new file mode 100644
index 0000000..3f6da8f
Binary files /dev/null and b/regress/corpus/007759a3d0ad4770ac6735cbfbe2b283c84db9a8 differ
diff --git a/regress/corpus/008d56444b810cede67853ab5734d4bc0b93c324 b/regress/corpus/008d56444b810cede67853ab5734d4bc0b93c324
new file mode 100644
index 0000000..873728f
Binary files /dev/null and b/regress/corpus/008d56444b810cede67853ab5734d4bc0b93c324 differ
diff --git a/regress/corpus/00e5f4561e6369edbaed2370f3d5d1bdabc98f0e b/regress/corpus/00e5f4561e6369edbaed2370f3d5d1bdabc98f0e
new file mode 100644
index 0000000..6d974d7
--- /dev/null
+++ b/regress/corpus/00e5f4561e6369edbaed2370f3d5d1bdabc98f0e
@@ -0,0 +1 @@
+Cû
\ No newline at end of file
diff --git a/regress/corpus/0188fac035ef7505df09b74514a8294a5be40309 b/regress/corpus/0188fac035ef7505df09b74514a8294a5be40309
new file mode 100644
index 0000000..b8b1af8
Binary files /dev/null and b/regress/corpus/0188fac035ef7505df09b74514a8294a5be40309 differ
diff --git a/regress/corpus/01db2df7e5a28208e8314e42128dfdc8cfb09e61 b/regress/corpus/01db2df7e5a28208e8314e42128dfdc8cfb09e61
new file mode 100644
index 0000000..23be356
Binary files /dev/null and b/regress/corpus/01db2df7e5a28208e8314e42128dfdc8cfb09e61 differ
diff --git a/regress/corpus/01eaa0a864b810272d0de33e0b308726fcc6b7a0 b/regress/corpus/01eaa0a864b810272d0de33e0b308726fcc6b7a0
new file mode 100644
index 0000000..a12c5af
Binary files /dev/null and b/regress/corpus/01eaa0a864b810272d0de33e0b308726fcc6b7a0 differ
diff --git a/regress/corpus/0227c6f644430f12005bbc938d74d644bf6d2386 b/regress/corpus/0227c6f644430f12005bbc938d74d644bf6d2386
new file mode 100644
index 0000000..e54e93a
Binary files /dev/null and b/regress/corpus/0227c6f644430f12005bbc938d74d644bf6d2386 differ
diff --git a/regress/corpus/024d8ac5ba6c7d4b17e3402b71f6e25978de5dfa b/regress/corpus/024d8ac5ba6c7d4b17e3402b71f6e25978de5dfa
new file mode 100644
index 0000000..7998ce1
Binary files /dev/null and b/regress/corpus/024d8ac5ba6c7d4b17e3402b71f6e25978de5dfa differ
diff --git a/regress/corpus/03508a1f2118f7b9329187a4a18d560a7693a303 b/regress/corpus/03508a1f2118f7b9329187a4a18d560a7693a303
new file mode 100644
index 0000000..3898003
Binary files /dev/null and b/regress/corpus/03508a1f2118f7b9329187a4a18d560a7693a303 differ
diff --git a/regress/corpus/03c2566deda1addb2dec223c310e357634dbd5b2 b/regress/corpus/03c2566deda1addb2dec223c310e357634dbd5b2
new file mode 100644
index 0000000..e700a16
Binary files /dev/null and b/regress/corpus/03c2566deda1addb2dec223c310e357634dbd5b2 differ
diff --git a/regress/corpus/03ed46f88cbc271f6b917f9e8f440c453604e65f b/regress/corpus/03ed46f88cbc271f6b917f9e8f440c453604e65f
new file mode 100644
index 0000000..9cc96d8
Binary files /dev/null and b/regress/corpus/03ed46f88cbc271f6b917f9e8f440c453604e65f differ
diff --git a/regress/corpus/0431bd5605a90814582ff87dc85914ec12b2a627 b/regress/corpus/0431bd5605a90814582ff87dc85914ec12b2a627
new file mode 100644
index 0000000..c517ff2
Binary files /dev/null and b/regress/corpus/0431bd5605a90814582ff87dc85914ec12b2a627 differ
diff --git a/regress/corpus/045193944d0a091aaf777fa05ed28330669b8437 b/regress/corpus/045193944d0a091aaf777fa05ed28330669b8437
new file mode 100644
index 0000000..6a78070
Binary files /dev/null and b/regress/corpus/045193944d0a091aaf777fa05ed28330669b8437 differ
diff --git a/regress/corpus/05d0dfbbb7b510344526f0a444bde750017ff92a b/regress/corpus/05d0dfbbb7b510344526f0a444bde750017ff92a
new file mode 100644
index 0000000..4fe53dd
Binary files /dev/null and b/regress/corpus/05d0dfbbb7b510344526f0a444bde750017ff92a differ
diff --git a/regress/corpus/05da2667ffae9e804304f1bea363f4300a58e7c9 b/regress/corpus/05da2667ffae9e804304f1bea363f4300a58e7c9
new file mode 100644
index 0000000..57722ee
Binary files /dev/null and b/regress/corpus/05da2667ffae9e804304f1bea363f4300a58e7c9 differ
diff --git a/regress/corpus/05df148b218b748bbfe7f37c13eaaedade5d6700 b/regress/corpus/05df148b218b748bbfe7f37c13eaaedade5d6700
new file mode 100644
index 0000000..489c075
Binary files /dev/null and b/regress/corpus/05df148b218b748bbfe7f37c13eaaedade5d6700 differ
diff --git a/regress/corpus/06a2a934e42a67ad77959b85e3c81fc7b2187f2f b/regress/corpus/06a2a934e42a67ad77959b85e3c81fc7b2187f2f
new file mode 100644
index 0000000..f6e1284
--- /dev/null
+++ b/regress/corpus/06a2a934e42a67ad77959b85e3c81fc7b2187f2f
@@ -0,0 +1 @@
+ÿ1
diff --git a/regress/corpus/070281d17a5345533517926c9b094351dace55c4 b/regress/corpus/070281d17a5345533517926c9b094351dace55c4
new file mode 100644
index 0000000..b68e4fc
Binary files /dev/null and b/regress/corpus/070281d17a5345533517926c9b094351dace55c4 differ
diff --git a/regress/corpus/0751788f2442c79a88122ac6c4586f531e655945 b/regress/corpus/0751788f2442c79a88122ac6c4586f531e655945
new file mode 100644
index 0000000..8e32fa4
Binary files /dev/null and b/regress/corpus/0751788f2442c79a88122ac6c4586f531e655945 differ
diff --git a/regress/corpus/07577f5bf8a0cb2522822c869db256b44cb25036 b/regress/corpus/07577f5bf8a0cb2522822c869db256b44cb25036
new file mode 100644
index 0000000..e459571
Binary files /dev/null and b/regress/corpus/07577f5bf8a0cb2522822c869db256b44cb25036 differ
diff --git a/regress/corpus/07683053fd336eba9122546c218f1d616213cd61 b/regress/corpus/07683053fd336eba9122546c218f1d616213cd61
new file mode 100644
index 0000000..d232531
Binary files /dev/null and b/regress/corpus/07683053fd336eba9122546c218f1d616213cd61 differ
diff --git a/regress/corpus/078f97947d8f0238b600f70b1df688d688fcd82c b/regress/corpus/078f97947d8f0238b600f70b1df688d688fcd82c
new file mode 100644
index 0000000..1a8a62d
Binary files /dev/null and b/regress/corpus/078f97947d8f0238b600f70b1df688d688fcd82c differ
diff --git a/regress/corpus/07c1942114ec7efada8baf028867bb58f8bc2662 b/regress/corpus/07c1942114ec7efada8baf028867bb58f8bc2662
new file mode 100644
index 0000000..17ce87c
Binary files /dev/null and b/regress/corpus/07c1942114ec7efada8baf028867bb58f8bc2662 differ
diff --git a/regress/corpus/084b1b4ee2578618858894a666d5718e8839d4c1 b/regress/corpus/084b1b4ee2578618858894a666d5718e8839d4c1
new file mode 100644
index 0000000..829e52c
Binary files /dev/null and b/regress/corpus/084b1b4ee2578618858894a666d5718e8839d4c1 differ
diff --git a/regress/corpus/0879f8a402eab5987839111e4c5ae0e2b068ec90 b/regress/corpus/0879f8a402eab5987839111e4c5ae0e2b068ec90
new file mode 100644
index 0000000..1481991
Binary files /dev/null and b/regress/corpus/0879f8a402eab5987839111e4c5ae0e2b068ec90 differ
diff --git a/regress/corpus/089dd17dbf3a8fb85d324f9927545e4c62744d3a b/regress/corpus/089dd17dbf3a8fb85d324f9927545e4c62744d3a
new file mode 100644
index 0000000..3b93286
Binary files /dev/null and b/regress/corpus/089dd17dbf3a8fb85d324f9927545e4c62744d3a differ
diff --git a/regress/corpus/08ce418686914f6d9d05ca6900ad66491452298a b/regress/corpus/08ce418686914f6d9d05ca6900ad66491452298a
new file mode 100644
index 0000000..3cbf630
--- /dev/null
+++ b/regress/corpus/08ce418686914f6d9d05ca6900ad66491452298a
@@ -0,0 +1 @@
+s{s
\ No newline at end of file
diff --git a/regress/corpus/08dbd70914157be6526309e2da61c12d727c3d33 b/regress/corpus/08dbd70914157be6526309e2da61c12d727c3d33
new file mode 100644
index 0000000..e1c0f26
Binary files /dev/null and b/regress/corpus/08dbd70914157be6526309e2da61c12d727c3d33 differ
diff --git a/regress/corpus/090d5c70fbca3713010e573cc99f7bce593fa32d b/regress/corpus/090d5c70fbca3713010e573cc99f7bce593fa32d
new file mode 100644
index 0000000..6dd859e
Binary files /dev/null and b/regress/corpus/090d5c70fbca3713010e573cc99f7bce593fa32d differ
diff --git a/regress/corpus/09548ccc77059b95196bbc13eb9f88e12676e70b b/regress/corpus/09548ccc77059b95196bbc13eb9f88e12676e70b
new file mode 100644
index 0000000..4b422fa
Binary files /dev/null and b/regress/corpus/09548ccc77059b95196bbc13eb9f88e12676e70b differ
diff --git a/regress/corpus/09ae93c969f72e208a82bfbb253907f99ad1677d b/regress/corpus/09ae93c969f72e208a82bfbb253907f99ad1677d
new file mode 100644
index 0000000..27bc5d7
Binary files /dev/null and b/regress/corpus/09ae93c969f72e208a82bfbb253907f99ad1677d differ
diff --git a/regress/corpus/09cdf4350c6896b029dd7ca590a7fc64dd754d8f b/regress/corpus/09cdf4350c6896b029dd7ca590a7fc64dd754d8f
new file mode 100644
index 0000000..62c1fd2
Binary files /dev/null and b/regress/corpus/09cdf4350c6896b029dd7ca590a7fc64dd754d8f differ
diff --git a/regress/corpus/09dcfa754505584a732d77622bed3c8772f95b4f b/regress/corpus/09dcfa754505584a732d77622bed3c8772f95b4f
new file mode 100644
index 0000000..0c70ec8
Binary files /dev/null and b/regress/corpus/09dcfa754505584a732d77622bed3c8772f95b4f differ
diff --git a/regress/corpus/0a8401e5dca56e461821a1fab11d0418c6999d7d b/regress/corpus/0a8401e5dca56e461821a1fab11d0418c6999d7d
new file mode 100644
index 0000000..44de44f
Binary files /dev/null and b/regress/corpus/0a8401e5dca56e461821a1fab11d0418c6999d7d differ
diff --git a/regress/corpus/0b70b1185a6aeb199d299db723474bee27aeb530 b/regress/corpus/0b70b1185a6aeb199d299db723474bee27aeb530
new file mode 100644
index 0000000..51b0827
Binary files /dev/null and b/regress/corpus/0b70b1185a6aeb199d299db723474bee27aeb530 differ
diff --git a/regress/corpus/0bb16e12d2fad1e48673f14f095a9c40f6dcd328 b/regress/corpus/0bb16e12d2fad1e48673f14f095a9c40f6dcd328
new file mode 100644
index 0000000..561d3a3
Binary files /dev/null and b/regress/corpus/0bb16e12d2fad1e48673f14f095a9c40f6dcd328 differ
diff --git a/regress/corpus/0bb4137672a5e51faaaa21f4af369e328a790ca3 b/regress/corpus/0bb4137672a5e51faaaa21f4af369e328a790ca3
new file mode 100644
index 0000000..69ca430
Binary files /dev/null and b/regress/corpus/0bb4137672a5e51faaaa21f4af369e328a790ca3 differ
diff --git a/regress/corpus/0c111d36719d266fe64ba239427ae2bc12433c23 b/regress/corpus/0c111d36719d266fe64ba239427ae2bc12433c23
new file mode 100644
index 0000000..6b14d98
Binary files /dev/null and b/regress/corpus/0c111d36719d266fe64ba239427ae2bc12433c23 differ
diff --git a/regress/corpus/0c1e1a587337ae4b17cdc501e732993bb9b1c457 b/regress/corpus/0c1e1a587337ae4b17cdc501e732993bb9b1c457
new file mode 100644
index 0000000..111bea0
Binary files /dev/null and b/regress/corpus/0c1e1a587337ae4b17cdc501e732993bb9b1c457 differ
diff --git a/regress/corpus/0c5202dd7025c4a582dcad0a7bab7cd15816a2e4 b/regress/corpus/0c5202dd7025c4a582dcad0a7bab7cd15816a2e4
new file mode 100644
index 0000000..9086f5f
Binary files /dev/null and b/regress/corpus/0c5202dd7025c4a582dcad0a7bab7cd15816a2e4 differ
diff --git a/regress/corpus/0c8ced20f9ae57363056192953119aa666c48005 b/regress/corpus/0c8ced20f9ae57363056192953119aa666c48005
new file mode 100644
index 0000000..a324bee
Binary files /dev/null and b/regress/corpus/0c8ced20f9ae57363056192953119aa666c48005 differ
diff --git a/regress/corpus/0ceef7251d02d2d1230e6e4913e1f4244a031cf5 b/regress/corpus/0ceef7251d02d2d1230e6e4913e1f4244a031cf5
new file mode 100644
index 0000000..b979a11
Binary files /dev/null and b/regress/corpus/0ceef7251d02d2d1230e6e4913e1f4244a031cf5 differ
diff --git a/regress/corpus/0d04943b4e691a5045e3ca3dd40c49e5222065c4 b/regress/corpus/0d04943b4e691a5045e3ca3dd40c49e5222065c4
new file mode 100644
index 0000000..52bba02
Binary files /dev/null and b/regress/corpus/0d04943b4e691a5045e3ca3dd40c49e5222065c4 differ
diff --git a/regress/corpus/0d530172e4e79615078789372c4b5e6e8ec69299 b/regress/corpus/0d530172e4e79615078789372c4b5e6e8ec69299
new file mode 100644
index 0000000..7d1baf1
Binary files /dev/null and b/regress/corpus/0d530172e4e79615078789372c4b5e6e8ec69299 differ
diff --git a/regress/corpus/0e36283c3c9f017cf7f98d6f022aa1ec4b65be51 b/regress/corpus/0e36283c3c9f017cf7f98d6f022aa1ec4b65be51
new file mode 100644
index 0000000..3c6d682
Binary files /dev/null and b/regress/corpus/0e36283c3c9f017cf7f98d6f022aa1ec4b65be51 differ
diff --git a/regress/corpus/0e46b8f3d2b4f81e15c340aec54c4c37b8d3204f b/regress/corpus/0e46b8f3d2b4f81e15c340aec54c4c37b8d3204f
new file mode 100644
index 0000000..c1a63e2
Binary files /dev/null and b/regress/corpus/0e46b8f3d2b4f81e15c340aec54c4c37b8d3204f differ
diff --git a/regress/corpus/0e7fd85344fe39368c8c6ada20d06242bb138440 b/regress/corpus/0e7fd85344fe39368c8c6ada20d06242bb138440
new file mode 100644
index 0000000..700d650
Binary files /dev/null and b/regress/corpus/0e7fd85344fe39368c8c6ada20d06242bb138440 differ
diff --git a/regress/corpus/0e9d04161ea47c24debe698faef14333461af0c3 b/regress/corpus/0e9d04161ea47c24debe698faef14333461af0c3
new file mode 100644
index 0000000..e8a7e27
Binary files /dev/null and b/regress/corpus/0e9d04161ea47c24debe698faef14333461af0c3 differ
diff --git a/regress/corpus/0ea7f19815fd98b9ecc9d73a567071e33381f650 b/regress/corpus/0ea7f19815fd98b9ecc9d73a567071e33381f650
new file mode 100644
index 0000000..ef6150a
Binary files /dev/null and b/regress/corpus/0ea7f19815fd98b9ecc9d73a567071e33381f650 differ
diff --git a/regress/corpus/0ebb441ff0ca3d0f47a6872eb1bdd70aa1342382 b/regress/corpus/0ebb441ff0ca3d0f47a6872eb1bdd70aa1342382
new file mode 100644
index 0000000..b66b823
Binary files /dev/null and b/regress/corpus/0ebb441ff0ca3d0f47a6872eb1bdd70aa1342382 differ
diff --git a/regress/corpus/0faa8549a74132bf15b21b5fac6d0c3b225d7f94 b/regress/corpus/0faa8549a74132bf15b21b5fac6d0c3b225d7f94
new file mode 100644
index 0000000..4a602e2
Binary files /dev/null and b/regress/corpus/0faa8549a74132bf15b21b5fac6d0c3b225d7f94 differ
diff --git a/regress/corpus/1036c6d879808bd115f9cea9b0844fcd00281be5 b/regress/corpus/1036c6d879808bd115f9cea9b0844fcd00281be5
new file mode 100644
index 0000000..ecb2e2f
Binary files /dev/null and b/regress/corpus/1036c6d879808bd115f9cea9b0844fcd00281be5 differ
diff --git a/regress/corpus/10569c7a83583dd4a78f8b36abbc4023e244d108 b/regress/corpus/10569c7a83583dd4a78f8b36abbc4023e244d108
new file mode 100644
index 0000000..c55875f
Binary files /dev/null and b/regress/corpus/10569c7a83583dd4a78f8b36abbc4023e244d108 differ
diff --git a/regress/corpus/109047ed91b7db609f037751f9926db0029d0cde b/regress/corpus/109047ed91b7db609f037751f9926db0029d0cde
new file mode 100644
index 0000000..2947cb0
Binary files /dev/null and b/regress/corpus/109047ed91b7db609f037751f9926db0029d0cde differ
diff --git a/regress/corpus/109b5957918c0e2f4b1071c308d0d3196848d1e0 b/regress/corpus/109b5957918c0e2f4b1071c308d0d3196848d1e0
new file mode 100644
index 0000000..a97fc5e
Binary files /dev/null and b/regress/corpus/109b5957918c0e2f4b1071c308d0d3196848d1e0 differ
diff --git a/regress/corpus/10a069bbf6320fe9923d6e7acb629fa2ac3c5c63 b/regress/corpus/10a069bbf6320fe9923d6e7acb629fa2ac3c5c63
new file mode 100644
index 0000000..e4f879f
Binary files /dev/null and b/regress/corpus/10a069bbf6320fe9923d6e7acb629fa2ac3c5c63 differ
diff --git a/regress/corpus/114065934a86956bac44a8c927a7d590e549fbf9 b/regress/corpus/114065934a86956bac44a8c927a7d590e549fbf9
new file mode 100644
index 0000000..fc821fe
Binary files /dev/null and b/regress/corpus/114065934a86956bac44a8c927a7d590e549fbf9 differ
diff --git a/regress/corpus/116f91e595122d77dcef49d6a833286c817e1866 b/regress/corpus/116f91e595122d77dcef49d6a833286c817e1866
new file mode 100644
index 0000000..7cc8c3f
Binary files /dev/null and b/regress/corpus/116f91e595122d77dcef49d6a833286c817e1866 differ
diff --git a/regress/corpus/11aa23868bc0bb6229ce09145652d039f77feae4 b/regress/corpus/11aa23868bc0bb6229ce09145652d039f77feae4
new file mode 100644
index 0000000..891e221
Binary files /dev/null and b/regress/corpus/11aa23868bc0bb6229ce09145652d039f77feae4 differ
diff --git a/regress/corpus/11b8d17be01eee8a910f6f9d5a4a095185932313 b/regress/corpus/11b8d17be01eee8a910f6f9d5a4a095185932313
new file mode 100644
index 0000000..b24d9d2
Binary files /dev/null and b/regress/corpus/11b8d17be01eee8a910f6f9d5a4a095185932313 differ
diff --git a/regress/corpus/12413b3a10b1891c40f60dbd8b8da85b89d6152a b/regress/corpus/12413b3a10b1891c40f60dbd8b8da85b89d6152a
new file mode 100644
index 0000000..c06e1eb
--- /dev/null
+++ b/regress/corpus/12413b3a10b1891c40f60dbd8b8da85b89d6152a
@@ -0,0 +1 @@
+™¢
\ No newline at end of file
diff --git a/regress/corpus/12a2f2831b895478fd299f4211ddaf12c69962e0 b/regress/corpus/12a2f2831b895478fd299f4211ddaf12c69962e0
new file mode 100644
index 0000000..226f499
Binary files /dev/null and b/regress/corpus/12a2f2831b895478fd299f4211ddaf12c69962e0 differ
diff --git a/regress/corpus/12c39d533878e2c90e4b84931fc43ba4e10ac59e b/regress/corpus/12c39d533878e2c90e4b84931fc43ba4e10ac59e
new file mode 100644
index 0000000..afba1a7
Binary files /dev/null and b/regress/corpus/12c39d533878e2c90e4b84931fc43ba4e10ac59e differ
diff --git a/regress/corpus/12f9bd56f1bb5eb8f052f6990333e30727152876 b/regress/corpus/12f9bd56f1bb5eb8f052f6990333e30727152876
new file mode 100644
index 0000000..464b539
Binary files /dev/null and b/regress/corpus/12f9bd56f1bb5eb8f052f6990333e30727152876 differ
diff --git a/regress/corpus/13015da08d5c46f57e1cef41893c26e46d73182e b/regress/corpus/13015da08d5c46f57e1cef41893c26e46d73182e
new file mode 100644
index 0000000..b3046f9
Binary files /dev/null and b/regress/corpus/13015da08d5c46f57e1cef41893c26e46d73182e differ
diff --git a/regress/corpus/1331912ce4e2480ac78825b9a76d449984082e7d b/regress/corpus/1331912ce4e2480ac78825b9a76d449984082e7d
new file mode 100644
index 0000000..a512c73
Binary files /dev/null and b/regress/corpus/1331912ce4e2480ac78825b9a76d449984082e7d differ
diff --git a/regress/corpus/133f01814c85c7cca7c83fa9ed39264f22a2b4d4 b/regress/corpus/133f01814c85c7cca7c83fa9ed39264f22a2b4d4
new file mode 100644
index 0000000..9d40df4
Binary files /dev/null and b/regress/corpus/133f01814c85c7cca7c83fa9ed39264f22a2b4d4 differ
diff --git a/regress/corpus/13b1da744fef6e3fdbdfab86cacd35ca6ccd4f35 b/regress/corpus/13b1da744fef6e3fdbdfab86cacd35ca6ccd4f35
new file mode 100644
index 0000000..336b13f
Binary files /dev/null and b/regress/corpus/13b1da744fef6e3fdbdfab86cacd35ca6ccd4f35 differ
diff --git a/regress/corpus/13b8616ab053af4ed4f840ec7adefd887a78fc8f b/regress/corpus/13b8616ab053af4ed4f840ec7adefd887a78fc8f
new file mode 100644
index 0000000..a003852
Binary files /dev/null and b/regress/corpus/13b8616ab053af4ed4f840ec7adefd887a78fc8f differ
diff --git a/regress/corpus/13cb0470382fcb0420b41b96168dfeeecb55e7e4 b/regress/corpus/13cb0470382fcb0420b41b96168dfeeecb55e7e4
new file mode 100644
index 0000000..9c71837
Binary files /dev/null and b/regress/corpus/13cb0470382fcb0420b41b96168dfeeecb55e7e4 differ
diff --git a/regress/corpus/13d303fe1e7655fde74811c8a695e8f2380ec23a b/regress/corpus/13d303fe1e7655fde74811c8a695e8f2380ec23a
new file mode 100644
index 0000000..db5491b
Binary files /dev/null and b/regress/corpus/13d303fe1e7655fde74811c8a695e8f2380ec23a differ
diff --git a/regress/corpus/148fb3267d4ba90f0bf7d85a1c7e3f464026587c b/regress/corpus/148fb3267d4ba90f0bf7d85a1c7e3f464026587c
new file mode 100644
index 0000000..44cbe40
Binary files /dev/null and b/regress/corpus/148fb3267d4ba90f0bf7d85a1c7e3f464026587c differ
diff --git a/regress/corpus/14dab8717b357f64951129dcc4c709254a35faf3 b/regress/corpus/14dab8717b357f64951129dcc4c709254a35faf3
new file mode 100644
index 0000000..81039d4
Binary files /dev/null and b/regress/corpus/14dab8717b357f64951129dcc4c709254a35faf3 differ
diff --git a/regress/corpus/14e81ef5ef747499a992048f1249cfb3f50b084a b/regress/corpus/14e81ef5ef747499a992048f1249cfb3f50b084a
new file mode 100644
index 0000000..2ec6175
Binary files /dev/null and b/regress/corpus/14e81ef5ef747499a992048f1249cfb3f50b084a differ
diff --git a/regress/corpus/150ad98fa141799e87aeb98134268cab7f504d83 b/regress/corpus/150ad98fa141799e87aeb98134268cab7f504d83
new file mode 100644
index 0000000..ec432ad
Binary files /dev/null and b/regress/corpus/150ad98fa141799e87aeb98134268cab7f504d83 differ
diff --git a/regress/corpus/155f97d79c5b25ed2908e976857e4881f5281e0f b/regress/corpus/155f97d79c5b25ed2908e976857e4881f5281e0f
new file mode 100644
index 0000000..8a0cb52
--- /dev/null
+++ b/regress/corpus/155f97d79c5b25ed2908e976857e4881f5281e0f
@@ -0,0 +1 @@
+¢ï
\ No newline at end of file
diff --git a/regress/corpus/15a0136358bc5ecca64f02500cde044317857bdd b/regress/corpus/15a0136358bc5ecca64f02500cde044317857bdd
new file mode 100644
index 0000000..908d71c
Binary files /dev/null and b/regress/corpus/15a0136358bc5ecca64f02500cde044317857bdd differ
diff --git a/regress/corpus/15d6c0eb199a0cf8407cd77b02bc166fc7557978 b/regress/corpus/15d6c0eb199a0cf8407cd77b02bc166fc7557978
new file mode 100644
index 0000000..e5f5ac5
Binary files /dev/null and b/regress/corpus/15d6c0eb199a0cf8407cd77b02bc166fc7557978 differ
diff --git a/regress/corpus/15e020c721b79eed0472629420c609fe8d73aa44 b/regress/corpus/15e020c721b79eed0472629420c609fe8d73aa44
new file mode 100644
index 0000000..da5992a
Binary files /dev/null and b/regress/corpus/15e020c721b79eed0472629420c609fe8d73aa44 differ
diff --git a/regress/corpus/163c1eb74b0fa85af99ad2d2eca7f5f8a4c437e3 b/regress/corpus/163c1eb74b0fa85af99ad2d2eca7f5f8a4c437e3
new file mode 100644
index 0000000..b4052fd
Binary files /dev/null and b/regress/corpus/163c1eb74b0fa85af99ad2d2eca7f5f8a4c437e3 differ
diff --git a/regress/corpus/16bdd353a506b00b8083f32fb8a75a19e76d748d b/regress/corpus/16bdd353a506b00b8083f32fb8a75a19e76d748d
new file mode 100644
index 0000000..4fb5e1c
Binary files /dev/null and b/regress/corpus/16bdd353a506b00b8083f32fb8a75a19e76d748d differ
diff --git a/regress/corpus/16dce872fb741b28f54af84fbd62b1df377296d9 b/regress/corpus/16dce872fb741b28f54af84fbd62b1df377296d9
new file mode 100644
index 0000000..4ecc937
Binary files /dev/null and b/regress/corpus/16dce872fb741b28f54af84fbd62b1df377296d9 differ
diff --git a/regress/corpus/1705eb67b97163b2a4447b51d4b262deef08d302 b/regress/corpus/1705eb67b97163b2a4447b51d4b262deef08d302
new file mode 100644
index 0000000..2e35fa3
Binary files /dev/null and b/regress/corpus/1705eb67b97163b2a4447b51d4b262deef08d302 differ
diff --git a/regress/corpus/176cfd5e4166af97eb9b793a50dbd60ecda2de46 b/regress/corpus/176cfd5e4166af97eb9b793a50dbd60ecda2de46
new file mode 100644
index 0000000..0da7fe7
--- /dev/null
+++ b/regress/corpus/176cfd5e4166af97eb9b793a50dbd60ecda2de46
@@ -0,0 +1 @@
+¾
\ No newline at end of file
diff --git a/regress/corpus/17e7febee26f41434a7cc99d6c4a17ac9a15095c b/regress/corpus/17e7febee26f41434a7cc99d6c4a17ac9a15095c
new file mode 100644
index 0000000..7154a53
Binary files /dev/null and b/regress/corpus/17e7febee26f41434a7cc99d6c4a17ac9a15095c differ
diff --git a/regress/corpus/1802f99fb886203d6287e472db4216ab8344bc9f b/regress/corpus/1802f99fb886203d6287e472db4216ab8344bc9f
new file mode 100644
index 0000000..cb8f151
Binary files /dev/null and b/regress/corpus/1802f99fb886203d6287e472db4216ab8344bc9f differ
diff --git a/regress/corpus/1898cd0fac2028a3c0d41d8e8c7d2a6cf52eb4a9 b/regress/corpus/1898cd0fac2028a3c0d41d8e8c7d2a6cf52eb4a9
new file mode 100644
index 0000000..f996b68
Binary files /dev/null and b/regress/corpus/1898cd0fac2028a3c0d41d8e8c7d2a6cf52eb4a9 differ
diff --git a/regress/corpus/1899b05b5143972980b704ef972ac2e6a590e87d b/regress/corpus/1899b05b5143972980b704ef972ac2e6a590e87d
new file mode 100644
index 0000000..4d9e87d
--- /dev/null
+++ b/regress/corpus/1899b05b5143972980b704ef972ac2e6a590e87d
@@ -0,0 +1 @@
+	¹
\ No newline at end of file
diff --git a/regress/corpus/18e487418afd8d37be70cb0e7e34bd73d8414390 b/regress/corpus/18e487418afd8d37be70cb0e7e34bd73d8414390
new file mode 100644
index 0000000..7affff0
Binary files /dev/null and b/regress/corpus/18e487418afd8d37be70cb0e7e34bd73d8414390 differ
diff --git a/regress/corpus/190f99c8d326c1356c722e734cbd47dbb612c05d b/regress/corpus/190f99c8d326c1356c722e734cbd47dbb612c05d
new file mode 100644
index 0000000..e7467dc
Binary files /dev/null and b/regress/corpus/190f99c8d326c1356c722e734cbd47dbb612c05d differ
diff --git a/regress/corpus/1b5968225b0149e27005adbc9d9904d6c1089700 b/regress/corpus/1b5968225b0149e27005adbc9d9904d6c1089700
new file mode 100644
index 0000000..dfc88c8
Binary files /dev/null and b/regress/corpus/1b5968225b0149e27005adbc9d9904d6c1089700 differ
diff --git a/regress/corpus/1b69d765862555d95cdd99e762a688954ad65ec3 b/regress/corpus/1b69d765862555d95cdd99e762a688954ad65ec3
new file mode 100644
index 0000000..ad2e9d1
Binary files /dev/null and b/regress/corpus/1b69d765862555d95cdd99e762a688954ad65ec3 differ
diff --git a/regress/corpus/1b7c228780a6e6f2cef1ef23b5645cab44882817 b/regress/corpus/1b7c228780a6e6f2cef1ef23b5645cab44882817
new file mode 100644
index 0000000..0a0ed6b
Binary files /dev/null and b/regress/corpus/1b7c228780a6e6f2cef1ef23b5645cab44882817 differ
diff --git a/regress/corpus/1b86fede95021fbbb3ce9f10702fab186085f0c5 b/regress/corpus/1b86fede95021fbbb3ce9f10702fab186085f0c5
new file mode 100644
index 0000000..9730e89
Binary files /dev/null and b/regress/corpus/1b86fede95021fbbb3ce9f10702fab186085f0c5 differ
diff --git a/regress/corpus/1bee83c30d4397fe22748cb8a5d0263af0a5bfa5 b/regress/corpus/1bee83c30d4397fe22748cb8a5d0263af0a5bfa5
new file mode 100644
index 0000000..675b560
Binary files /dev/null and b/regress/corpus/1bee83c30d4397fe22748cb8a5d0263af0a5bfa5 differ
diff --git a/regress/corpus/1d2309f333c0de06793aeba6b6a878e39f01d14e b/regress/corpus/1d2309f333c0de06793aeba6b6a878e39f01d14e
new file mode 100644
index 0000000..901fc41
Binary files /dev/null and b/regress/corpus/1d2309f333c0de06793aeba6b6a878e39f01d14e differ
diff --git a/regress/corpus/1dcc8e264291d11828b0b22270a420b6817becd1 b/regress/corpus/1dcc8e264291d11828b0b22270a420b6817becd1
new file mode 100644
index 0000000..0d9571e
Binary files /dev/null and b/regress/corpus/1dcc8e264291d11828b0b22270a420b6817becd1 differ
diff --git a/regress/corpus/1dcd97a6b805af5f65f53e71fea02cf65156da7d b/regress/corpus/1dcd97a6b805af5f65f53e71fea02cf65156da7d
new file mode 100644
index 0000000..34e4bc7
Binary files /dev/null and b/regress/corpus/1dcd97a6b805af5f65f53e71fea02cf65156da7d differ
diff --git a/regress/corpus/1e991f051e14b8aa9ea3f0554455f3076301b446 b/regress/corpus/1e991f051e14b8aa9ea3f0554455f3076301b446
new file mode 100644
index 0000000..6cc7f27
Binary files /dev/null and b/regress/corpus/1e991f051e14b8aa9ea3f0554455f3076301b446 differ
diff --git a/regress/corpus/1ee638dfe721e629b52855ca4cdc7181d9bc5a46 b/regress/corpus/1ee638dfe721e629b52855ca4cdc7181d9bc5a46
new file mode 100644
index 0000000..a7bf9ff
Binary files /dev/null and b/regress/corpus/1ee638dfe721e629b52855ca4cdc7181d9bc5a46 differ
diff --git a/regress/corpus/1efef1d21fe7ec059e997c828239f22284d9a0fb b/regress/corpus/1efef1d21fe7ec059e997c828239f22284d9a0fb
new file mode 100644
index 0000000..7ae7097
--- /dev/null
+++ b/regress/corpus/1efef1d21fe7ec059e997c828239f22284d9a0fb
@@ -0,0 +1 @@
+88888888888È8888888888888888ŽŽŽŽŽ88(888888€888888888888888888888860000000007960p67591810391152
ôÿÿœ�MMM²²²
\ No newline at end of file
diff --git a/regress/corpus/1f5ce31cf0d778db8f47d8a1cd9a9d109e55abf3 b/regress/corpus/1f5ce31cf0d778db8f47d8a1cd9a9d109e55abf3
new file mode 100644
index 0000000..fa10f3b
Binary files /dev/null and b/regress/corpus/1f5ce31cf0d778db8f47d8a1cd9a9d109e55abf3 differ
diff --git a/regress/corpus/1f7ccbe5fb0d0f2c48dbd71856f5bb4c79742af5 b/regress/corpus/1f7ccbe5fb0d0f2c48dbd71856f5bb4c79742af5
new file mode 100644
index 0000000..fa30d43
Binary files /dev/null and b/regress/corpus/1f7ccbe5fb0d0f2c48dbd71856f5bb4c79742af5 differ
diff --git a/regress/corpus/1facdc854b196ac7ac14767c8496c36d60d26cdf b/regress/corpus/1facdc854b196ac7ac14767c8496c36d60d26cdf
new file mode 100644
index 0000000..eb3977a
Binary files /dev/null and b/regress/corpus/1facdc854b196ac7ac14767c8496c36d60d26cdf differ
diff --git a/regress/corpus/1fb37ac0ae4e8f55b738aa74464753492441ba7d b/regress/corpus/1fb37ac0ae4e8f55b738aa74464753492441ba7d
new file mode 100644
index 0000000..2e3a198
Binary files /dev/null and b/regress/corpus/1fb37ac0ae4e8f55b738aa74464753492441ba7d differ
diff --git a/regress/corpus/1ffe2d52cb820525e38d1605a0a359eebdb398e7 b/regress/corpus/1ffe2d52cb820525e38d1605a0a359eebdb398e7
new file mode 100644
index 0000000..7f212f6
Binary files /dev/null and b/regress/corpus/1ffe2d52cb820525e38d1605a0a359eebdb398e7 differ
diff --git a/regress/corpus/2013e9a73cc1bfd83507c175392a599986ee2f18 b/regress/corpus/2013e9a73cc1bfd83507c175392a599986ee2f18
new file mode 100644
index 0000000..13e9be7
Binary files /dev/null and b/regress/corpus/2013e9a73cc1bfd83507c175392a599986ee2f18 differ
diff --git a/regress/corpus/2068977c49df1d3d18995173c9d9edae79054fe5 b/regress/corpus/2068977c49df1d3d18995173c9d9edae79054fe5
new file mode 100644
index 0000000..7f76b25
Binary files /dev/null and b/regress/corpus/2068977c49df1d3d18995173c9d9edae79054fe5 differ
diff --git a/regress/corpus/209b7345bb9819a7c1f3aeb20919a79f963d38d6 b/regress/corpus/209b7345bb9819a7c1f3aeb20919a79f963d38d6
new file mode 100644
index 0000000..7c0ddc5
Binary files /dev/null and b/regress/corpus/209b7345bb9819a7c1f3aeb20919a79f963d38d6 differ
diff --git a/regress/corpus/20c5609f737b9d69e29b5998f29a995de2c2ee8c b/regress/corpus/20c5609f737b9d69e29b5998f29a995de2c2ee8c
new file mode 100644
index 0000000..cd3ca05
Binary files /dev/null and b/regress/corpus/20c5609f737b9d69e29b5998f29a995de2c2ee8c differ
diff --git a/regress/corpus/20e120edd7b7be5f6386dbc3dd6f9426deb004b3 b/regress/corpus/20e120edd7b7be5f6386dbc3dd6f9426deb004b3
new file mode 100644
index 0000000..e205239
Binary files /dev/null and b/regress/corpus/20e120edd7b7be5f6386dbc3dd6f9426deb004b3 differ
diff --git a/regress/corpus/20e47755852cece76433bf3e1b2534272f555a84 b/regress/corpus/20e47755852cece76433bf3e1b2534272f555a84
new file mode 100644
index 0000000..f9846a2
Binary files /dev/null and b/regress/corpus/20e47755852cece76433bf3e1b2534272f555a84 differ
diff --git a/regress/corpus/21dc08e05bce2e6f9f20f5933a1e433c4e316666 b/regress/corpus/21dc08e05bce2e6f9f20f5933a1e433c4e316666
new file mode 100644
index 0000000..2f02906
Binary files /dev/null and b/regress/corpus/21dc08e05bce2e6f9f20f5933a1e433c4e316666 differ
diff --git a/regress/corpus/225115d7103c4ac3cbcb855cc757a4bbe38bde32 b/regress/corpus/225115d7103c4ac3cbcb855cc757a4bbe38bde32
new file mode 100644
index 0000000..f451641
Binary files /dev/null and b/regress/corpus/225115d7103c4ac3cbcb855cc757a4bbe38bde32 differ
diff --git a/regress/corpus/22c3b3391ae022650859313249c74ec144a4725b b/regress/corpus/22c3b3391ae022650859313249c74ec144a4725b
new file mode 100644
index 0000000..254f0b0
Binary files /dev/null and b/regress/corpus/22c3b3391ae022650859313249c74ec144a4725b differ
diff --git a/regress/corpus/22c932275b06c0d00fac1ff09a8755918f6ba6a6 b/regress/corpus/22c932275b06c0d00fac1ff09a8755918f6ba6a6
new file mode 100644
index 0000000..822baea
Binary files /dev/null and b/regress/corpus/22c932275b06c0d00fac1ff09a8755918f6ba6a6 differ
diff --git a/regress/corpus/232a46d2379702729f340d89e47fffb3c9c93498 b/regress/corpus/232a46d2379702729f340d89e47fffb3c9c93498
new file mode 100644
index 0000000..7c529a5
Binary files /dev/null and b/regress/corpus/232a46d2379702729f340d89e47fffb3c9c93498 differ
diff --git a/regress/corpus/23d09b303daced036b29340ee28756b0f96e637f b/regress/corpus/23d09b303daced036b29340ee28756b0f96e637f
new file mode 100644
index 0000000..2a66a2e
Binary files /dev/null and b/regress/corpus/23d09b303daced036b29340ee28756b0f96e637f differ
diff --git a/regress/corpus/2459f75de1b77cff2593457199afec81627c3c15 b/regress/corpus/2459f75de1b77cff2593457199afec81627c3c15
new file mode 100644
index 0000000..82584a7
Binary files /dev/null and b/regress/corpus/2459f75de1b77cff2593457199afec81627c3c15 differ
diff --git a/regress/corpus/24e534c53b2c1845ba1fa8724642f7396bd75b86 b/regress/corpus/24e534c53b2c1845ba1fa8724642f7396bd75b86
new file mode 100644
index 0000000..4ea800f
Binary files /dev/null and b/regress/corpus/24e534c53b2c1845ba1fa8724642f7396bd75b86 differ
diff --git a/regress/corpus/24e9f8aef329fd55f96e1ccf93ec58de70d73418 b/regress/corpus/24e9f8aef329fd55f96e1ccf93ec58de70d73418
new file mode 100644
index 0000000..652feae
Binary files /dev/null and b/regress/corpus/24e9f8aef329fd55f96e1ccf93ec58de70d73418 differ
diff --git a/regress/corpus/258b492b1717ca501b5f9afcc1ca6b72582458a3 b/regress/corpus/258b492b1717ca501b5f9afcc1ca6b72582458a3
new file mode 100644
index 0000000..028255c
Binary files /dev/null and b/regress/corpus/258b492b1717ca501b5f9afcc1ca6b72582458a3 differ
diff --git a/regress/corpus/25e35a8badd4df4aa19dbbc45cf9935fa240fdaf b/regress/corpus/25e35a8badd4df4aa19dbbc45cf9935fa240fdaf
new file mode 100644
index 0000000..a82ab56
Binary files /dev/null and b/regress/corpus/25e35a8badd4df4aa19dbbc45cf9935fa240fdaf differ
diff --git a/regress/corpus/25f6a3963bd5a37aec83b3a8b70917fb22875a01 b/regress/corpus/25f6a3963bd5a37aec83b3a8b70917fb22875a01
new file mode 100644
index 0000000..5bd80b4
Binary files /dev/null and b/regress/corpus/25f6a3963bd5a37aec83b3a8b70917fb22875a01 differ
diff --git a/regress/corpus/2639bf7fd8827e464e734665f7c8c7a76a88d95b b/regress/corpus/2639bf7fd8827e464e734665f7c8c7a76a88d95b
new file mode 100644
index 0000000..d4f4d77
Binary files /dev/null and b/regress/corpus/2639bf7fd8827e464e734665f7c8c7a76a88d95b differ
diff --git a/regress/corpus/2644fbb18502f0e2c22579cedb87286d7b175c19 b/regress/corpus/2644fbb18502f0e2c22579cedb87286d7b175c19
new file mode 100644
index 0000000..1210c3f
Binary files /dev/null and b/regress/corpus/2644fbb18502f0e2c22579cedb87286d7b175c19 differ
diff --git a/regress/corpus/2670e8c759611cba43c8f6f3c29067c07e50c0c0 b/regress/corpus/2670e8c759611cba43c8f6f3c29067c07e50c0c0
new file mode 100644
index 0000000..d8a9c38
Binary files /dev/null and b/regress/corpus/2670e8c759611cba43c8f6f3c29067c07e50c0c0 differ
diff --git a/regress/corpus/2681119d4f143dc2da3fea860ff9c96a00bad059 b/regress/corpus/2681119d4f143dc2da3fea860ff9c96a00bad059
new file mode 100644
index 0000000..3fb9d50
--- /dev/null
+++ b/regress/corpus/2681119d4f143dc2da3fea860ff9c96a00bad059
@@ -0,0 +1 @@
+

ÿÿÿÿÿ¹ÿÿÿÿÿÿ¹ÿ

ÿÿÿÿÿ¹ÿÿÿÿÿÿ¹ÿÿ
\ No newline at end of file
diff --git a/regress/corpus/2684729a8b4379f9a9587fd9157a0e2d21de9a6f b/regress/corpus/2684729a8b4379f9a9587fd9157a0e2d21de9a6f
new file mode 100644
index 0000000..6f33c77
Binary files /dev/null and b/regress/corpus/2684729a8b4379f9a9587fd9157a0e2d21de9a6f differ
diff --git a/regress/corpus/26fc80ecf848c3f7244c281e4520371d71f3107e b/regress/corpus/26fc80ecf848c3f7244c281e4520371d71f3107e
new file mode 100644
index 0000000..23c0b67
Binary files /dev/null and b/regress/corpus/26fc80ecf848c3f7244c281e4520371d71f3107e differ
diff --git a/regress/corpus/274709eba6e19af0d3ebfa0beb74148ea48355a0 b/regress/corpus/274709eba6e19af0d3ebfa0beb74148ea48355a0
new file mode 100644
index 0000000..9368644
Binary files /dev/null and b/regress/corpus/274709eba6e19af0d3ebfa0beb74148ea48355a0 differ
diff --git a/regress/corpus/2785d2b5293c8e69361fd91b0947d474afd91eb8 b/regress/corpus/2785d2b5293c8e69361fd91b0947d474afd91eb8
new file mode 100644
index 0000000..2733edd
Binary files /dev/null and b/regress/corpus/2785d2b5293c8e69361fd91b0947d474afd91eb8 differ
diff --git a/regress/corpus/2788a4b3b098433709f617edca10aac90eb57448 b/regress/corpus/2788a4b3b098433709f617edca10aac90eb57448
new file mode 100644
index 0000000..dc97f22
Binary files /dev/null and b/regress/corpus/2788a4b3b098433709f617edca10aac90eb57448 differ
diff --git a/regress/corpus/278f043071ca288700e8f5414f659626dcad36cc b/regress/corpus/278f043071ca288700e8f5414f659626dcad36cc
new file mode 100644
index 0000000..0e00bf1
Binary files /dev/null and b/regress/corpus/278f043071ca288700e8f5414f659626dcad36cc differ
diff --git a/regress/corpus/27c7e5a7e4fc98caf6a970101f0edd78a57e08a3 b/regress/corpus/27c7e5a7e4fc98caf6a970101f0edd78a57e08a3
new file mode 100644
index 0000000..0127210
Binary files /dev/null and b/regress/corpus/27c7e5a7e4fc98caf6a970101f0edd78a57e08a3 differ
diff --git a/regress/corpus/27d6a6160a332ce599561d6352e6ac6af9538efd b/regress/corpus/27d6a6160a332ce599561d6352e6ac6af9538efd
new file mode 100644
index 0000000..d296fbf
Binary files /dev/null and b/regress/corpus/27d6a6160a332ce599561d6352e6ac6af9538efd differ
diff --git a/regress/corpus/284b58105a89c89dfc0b816d7ddad5c06d70a342 b/regress/corpus/284b58105a89c89dfc0b816d7ddad5c06d70a342
new file mode 100644
index 0000000..35e1c62
Binary files /dev/null and b/regress/corpus/284b58105a89c89dfc0b816d7ddad5c06d70a342 differ
diff --git a/regress/corpus/287a41f434d33bb58ae0ab36ae0c2de40d2990eb b/regress/corpus/287a41f434d33bb58ae0ab36ae0c2de40d2990eb
new file mode 100644
index 0000000..c743ea1
Binary files /dev/null and b/regress/corpus/287a41f434d33bb58ae0ab36ae0c2de40d2990eb differ
diff --git a/regress/corpus/28a275f67c02f8569d6449841167c71de208ee84 b/regress/corpus/28a275f67c02f8569d6449841167c71de208ee84
new file mode 100644
index 0000000..f9e1952
Binary files /dev/null and b/regress/corpus/28a275f67c02f8569d6449841167c71de208ee84 differ
diff --git a/regress/corpus/28d88d81f5f97872f9106f1be4ebe21818276a08 b/regress/corpus/28d88d81f5f97872f9106f1be4ebe21818276a08
new file mode 100644
index 0000000..22fedf3
Binary files /dev/null and b/regress/corpus/28d88d81f5f97872f9106f1be4ebe21818276a08 differ
diff --git a/regress/corpus/2929aa365eb8905608f619efa7b0f9d1a47e41ec b/regress/corpus/2929aa365eb8905608f619efa7b0f9d1a47e41ec
new file mode 100644
index 0000000..0494e95
Binary files /dev/null and b/regress/corpus/2929aa365eb8905608f619efa7b0f9d1a47e41ec differ
diff --git a/regress/corpus/2967c03b7326d976d86bb910242c5c6a5245972d b/regress/corpus/2967c03b7326d976d86bb910242c5c6a5245972d
new file mode 100644
index 0000000..44be639
Binary files /dev/null and b/regress/corpus/2967c03b7326d976d86bb910242c5c6a5245972d differ
diff --git a/regress/corpus/299526d0acfde5aa4f91aa30a230d03fe20912f9 b/regress/corpus/299526d0acfde5aa4f91aa30a230d03fe20912f9
new file mode 100644
index 0000000..ccf6cec
Binary files /dev/null and b/regress/corpus/299526d0acfde5aa4f91aa30a230d03fe20912f9 differ
diff --git a/regress/corpus/29abb68d8f80967510e56cb5ef269be410176897 b/regress/corpus/29abb68d8f80967510e56cb5ef269be410176897
new file mode 100644
index 0000000..50f5e1d
Binary files /dev/null and b/regress/corpus/29abb68d8f80967510e56cb5ef269be410176897 differ
diff --git a/regress/corpus/29f318e193aac254f4f4affac13577e9a6db812f b/regress/corpus/29f318e193aac254f4f4affac13577e9a6db812f
new file mode 100644
index 0000000..6f3be80
Binary files /dev/null and b/regress/corpus/29f318e193aac254f4f4affac13577e9a6db812f differ
diff --git a/regress/corpus/2a2cd720a141b512a71915dcf608a41fa4bb5d24 b/regress/corpus/2a2cd720a141b512a71915dcf608a41fa4bb5d24
new file mode 100644
index 0000000..cdc0032
Binary files /dev/null and b/regress/corpus/2a2cd720a141b512a71915dcf608a41fa4bb5d24 differ
diff --git a/regress/corpus/2a3c1eb1affc0cd76d261449f86092008f620a9c b/regress/corpus/2a3c1eb1affc0cd76d261449f86092008f620a9c
new file mode 100644
index 0000000..8b12312
Binary files /dev/null and b/regress/corpus/2a3c1eb1affc0cd76d261449f86092008f620a9c differ
diff --git a/regress/corpus/2a443a99441ad42c30179ae728c008efc540f887 b/regress/corpus/2a443a99441ad42c30179ae728c008efc540f887
new file mode 100644
index 0000000..9c1c484
Binary files /dev/null and b/regress/corpus/2a443a99441ad42c30179ae728c008efc540f887 differ
diff --git a/regress/corpus/2a4f29ecaa5cd9ca8e8efd8b0b1235d8fd804e5f b/regress/corpus/2a4f29ecaa5cd9ca8e8efd8b0b1235d8fd804e5f
new file mode 100644
index 0000000..1ae1df8
Binary files /dev/null and b/regress/corpus/2a4f29ecaa5cd9ca8e8efd8b0b1235d8fd804e5f differ
diff --git a/regress/corpus/2a965ee6a7ce02a05004a18851a127836158536e b/regress/corpus/2a965ee6a7ce02a05004a18851a127836158536e
new file mode 100644
index 0000000..efff7ef
Binary files /dev/null and b/regress/corpus/2a965ee6a7ce02a05004a18851a127836158536e differ
diff --git a/regress/corpus/2aa8b41d4e859203e7be58ee8075081f13e3b921 b/regress/corpus/2aa8b41d4e859203e7be58ee8075081f13e3b921
new file mode 100644
index 0000000..0c14cc3
Binary files /dev/null and b/regress/corpus/2aa8b41d4e859203e7be58ee8075081f13e3b921 differ
diff --git a/regress/corpus/2aaf25fa3e4b42aa07f21df0ad7fcb6803aa0880 b/regress/corpus/2aaf25fa3e4b42aa07f21df0ad7fcb6803aa0880
new file mode 100644
index 0000000..c1b2a19
Binary files /dev/null and b/regress/corpus/2aaf25fa3e4b42aa07f21df0ad7fcb6803aa0880 differ
diff --git a/regress/corpus/2ab293e6fd7dbc1fdafd25df72811b4213697dd3 b/regress/corpus/2ab293e6fd7dbc1fdafd25df72811b4213697dd3
new file mode 100644
index 0000000..328599f
--- /dev/null
+++ b/regress/corpus/2ab293e6fd7dbc1fdafd25df72811b4213697dd3
@@ -0,0 +1 @@
+¹¹ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
\ No newline at end of file
diff --git a/regress/corpus/2b6b9bb40e334b52ff2a8a56bdbda98987bfc7ff b/regress/corpus/2b6b9bb40e334b52ff2a8a56bdbda98987bfc7ff
new file mode 100644
index 0000000..7d5ac15
Binary files /dev/null and b/regress/corpus/2b6b9bb40e334b52ff2a8a56bdbda98987bfc7ff differ
diff --git a/regress/corpus/2b813f8a1d791bdca3a228eae39e74382630e098 b/regress/corpus/2b813f8a1d791bdca3a228eae39e74382630e098
new file mode 100644
index 0000000..2607c41
Binary files /dev/null and b/regress/corpus/2b813f8a1d791bdca3a228eae39e74382630e098 differ
diff --git a/regress/corpus/2bed39c7a4efafec1bb8b811132215e4cc303159 b/regress/corpus/2bed39c7a4efafec1bb8b811132215e4cc303159
new file mode 100644
index 0000000..b6ab6e1
Binary files /dev/null and b/regress/corpus/2bed39c7a4efafec1bb8b811132215e4cc303159 differ
diff --git a/regress/corpus/2c32896351e957a3c091f16dc5535f6acce71a39 b/regress/corpus/2c32896351e957a3c091f16dc5535f6acce71a39
new file mode 100644
index 0000000..471da71
Binary files /dev/null and b/regress/corpus/2c32896351e957a3c091f16dc5535f6acce71a39 differ
diff --git a/regress/corpus/2c7c612c0304da7723d1c19c8d678af8be47da53 b/regress/corpus/2c7c612c0304da7723d1c19c8d678af8be47da53
new file mode 100644
index 0000000..7738f00
Binary files /dev/null and b/regress/corpus/2c7c612c0304da7723d1c19c8d678af8be47da53 differ
diff --git a/regress/corpus/2c8f63015f30edf62cf2540e7e8489b881235e64 b/regress/corpus/2c8f63015f30edf62cf2540e7e8489b881235e64
new file mode 100644
index 0000000..262592f
Binary files /dev/null and b/regress/corpus/2c8f63015f30edf62cf2540e7e8489b881235e64 differ
diff --git a/regress/corpus/2d17624b92f3d77c188f21d5e378dec96740062e b/regress/corpus/2d17624b92f3d77c188f21d5e378dec96740062e
new file mode 100644
index 0000000..2e3a3c6
Binary files /dev/null and b/regress/corpus/2d17624b92f3d77c188f21d5e378dec96740062e differ
diff --git a/regress/corpus/2d3e2b4bb1dc338154113cb3b5d74f110729b59f b/regress/corpus/2d3e2b4bb1dc338154113cb3b5d74f110729b59f
new file mode 100644
index 0000000..06297ff
Binary files /dev/null and b/regress/corpus/2d3e2b4bb1dc338154113cb3b5d74f110729b59f differ
diff --git a/regress/corpus/2d4b8ac96e29a06a4b6e15f38fec1f4f9f373cb0 b/regress/corpus/2d4b8ac96e29a06a4b6e15f38fec1f4f9f373cb0
new file mode 100644
index 0000000..d77d3c3
Binary files /dev/null and b/regress/corpus/2d4b8ac96e29a06a4b6e15f38fec1f4f9f373cb0 differ
diff --git a/regress/corpus/2d968b48bde767b013d3b4d6d09afd55d95d4506 b/regress/corpus/2d968b48bde767b013d3b4d6d09afd55d95d4506
new file mode 100644
index 0000000..10a6828
Binary files /dev/null and b/regress/corpus/2d968b48bde767b013d3b4d6d09afd55d95d4506 differ
diff --git a/regress/corpus/2d9c2bcd663bab5c17e3e1ae6690218abe1d9df9 b/regress/corpus/2d9c2bcd663bab5c17e3e1ae6690218abe1d9df9
new file mode 100644
index 0000000..080980f
Binary files /dev/null and b/regress/corpus/2d9c2bcd663bab5c17e3e1ae6690218abe1d9df9 differ
diff --git a/regress/corpus/2dbc9b7cd7847b9da50ec7f9a7c5bf191ed2b900 b/regress/corpus/2dbc9b7cd7847b9da50ec7f9a7c5bf191ed2b900
new file mode 100644
index 0000000..7ff9481
Binary files /dev/null and b/regress/corpus/2dbc9b7cd7847b9da50ec7f9a7c5bf191ed2b900 differ
diff --git a/regress/corpus/2dddb569d67174115a1b19323a6186f4fef484e3 b/regress/corpus/2dddb569d67174115a1b19323a6186f4fef484e3
new file mode 100644
index 0000000..52af6bd
Binary files /dev/null and b/regress/corpus/2dddb569d67174115a1b19323a6186f4fef484e3 differ
diff --git a/regress/corpus/2e7e89fe53b4273edf1f2be21931e8db12dc530c b/regress/corpus/2e7e89fe53b4273edf1f2be21931e8db12dc530c
new file mode 100644
index 0000000..9e6e88b
--- /dev/null
+++ b/regress/corpus/2e7e89fe53b4273edf1f2be21931e8db12dc530c
@@ -0,0 +1 @@
+8üÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝ
\ No newline at end of file
diff --git a/regress/corpus/2ef35dbabd9ba2c5690c80157c5dd6bf8ed346c6 b/regress/corpus/2ef35dbabd9ba2c5690c80157c5dd6bf8ed346c6
new file mode 100644
index 0000000..c7a9e70
Binary files /dev/null and b/regress/corpus/2ef35dbabd9ba2c5690c80157c5dd6bf8ed346c6 differ
diff --git a/regress/corpus/2f1ac793e74e7fcb020125cd4d7ad941c7113709 b/regress/corpus/2f1ac793e74e7fcb020125cd4d7ad941c7113709
new file mode 100644
index 0000000..04200d4
Binary files /dev/null and b/regress/corpus/2f1ac793e74e7fcb020125cd4d7ad941c7113709 differ
diff --git a/regress/corpus/2f5e27af4ddf6e2bcfb022d57f9d2fefd327adfa b/regress/corpus/2f5e27af4ddf6e2bcfb022d57f9d2fefd327adfa
new file mode 100644
index 0000000..5da6d50
Binary files /dev/null and b/regress/corpus/2f5e27af4ddf6e2bcfb022d57f9d2fefd327adfa differ
diff --git a/regress/corpus/2f7957edf4956a19a4dacbd977fd78aeb006b673 b/regress/corpus/2f7957edf4956a19a4dacbd977fd78aeb006b673
new file mode 100644
index 0000000..44c57e0
Binary files /dev/null and b/regress/corpus/2f7957edf4956a19a4dacbd977fd78aeb006b673 differ
diff --git a/regress/corpus/2fb870f6dd282bc931a49cf5de4b09e26c6b71fd b/regress/corpus/2fb870f6dd282bc931a49cf5de4b09e26c6b71fd
new file mode 100644
index 0000000..08675ce
Binary files /dev/null and b/regress/corpus/2fb870f6dd282bc931a49cf5de4b09e26c6b71fd differ
diff --git a/regress/corpus/300e4721e35934f03c836a69d92ab7faba459792 b/regress/corpus/300e4721e35934f03c836a69d92ab7faba459792
new file mode 100644
index 0000000..553d33f
Binary files /dev/null and b/regress/corpus/300e4721e35934f03c836a69d92ab7faba459792 differ
diff --git a/regress/corpus/3010964490465fc0165733cc957861c8542f1e23 b/regress/corpus/3010964490465fc0165733cc957861c8542f1e23
new file mode 100644
index 0000000..9a45b42
Binary files /dev/null and b/regress/corpus/3010964490465fc0165733cc957861c8542f1e23 differ
diff --git a/regress/corpus/303cd9332ba168a1236bc6bdaede24e3a2d3d34c b/regress/corpus/303cd9332ba168a1236bc6bdaede24e3a2d3d34c
new file mode 100644
index 0000000..9c4a8e7
Binary files /dev/null and b/regress/corpus/303cd9332ba168a1236bc6bdaede24e3a2d3d34c differ
diff --git a/regress/corpus/3058c1b168ddb4f64ada0d80dd85bd866f61f5f2 b/regress/corpus/3058c1b168ddb4f64ada0d80dd85bd866f61f5f2
new file mode 100644
index 0000000..de8c96e
Binary files /dev/null and b/regress/corpus/3058c1b168ddb4f64ada0d80dd85bd866f61f5f2 differ
diff --git a/regress/corpus/30a6be573b7ea9b40b03863295d1a53b724acfad b/regress/corpus/30a6be573b7ea9b40b03863295d1a53b724acfad
new file mode 100644
index 0000000..0af3abd
Binary files /dev/null and b/regress/corpus/30a6be573b7ea9b40b03863295d1a53b724acfad differ
diff --git a/regress/corpus/30f1ff183a8fc2826d795d8cd062249781f2440c b/regress/corpus/30f1ff183a8fc2826d795d8cd062249781f2440c
new file mode 100644
index 0000000..980148c
Binary files /dev/null and b/regress/corpus/30f1ff183a8fc2826d795d8cd062249781f2440c differ
diff --git a/regress/corpus/31072690f473a69093626af90f1fb6a48522b99f b/regress/corpus/31072690f473a69093626af90f1fb6a48522b99f
new file mode 100644
index 0000000..2ca0995
Binary files /dev/null and b/regress/corpus/31072690f473a69093626af90f1fb6a48522b99f differ
diff --git a/regress/corpus/311b3909dd9ee0d129484aa77e8d50f26f33b7e3 b/regress/corpus/311b3909dd9ee0d129484aa77e8d50f26f33b7e3
new file mode 100644
index 0000000..280dfa7
Binary files /dev/null and b/regress/corpus/311b3909dd9ee0d129484aa77e8d50f26f33b7e3 differ
diff --git a/regress/corpus/319058dbfda82da45689707a1022f2a29ff2deab b/regress/corpus/319058dbfda82da45689707a1022f2a29ff2deab
new file mode 100644
index 0000000..418b139
Binary files /dev/null and b/regress/corpus/319058dbfda82da45689707a1022f2a29ff2deab differ
diff --git a/regress/corpus/3193c89c5787c9dd98b9a0855e1759d5a98cf4d0 b/regress/corpus/3193c89c5787c9dd98b9a0855e1759d5a98cf4d0
new file mode 100644
index 0000000..ada7621
--- /dev/null
+++ b/regress/corpus/3193c89c5787c9dd98b9a0855e1759d5a98cf4d0
@@ -0,0 +1 @@
+

ÿÿÿ¹ÿÿÿÿÿÿ¹ÿÿÿ
\ No newline at end of file
diff --git a/regress/corpus/323130e242fce4de003bdde4f4b1216d3ebb30a2 b/regress/corpus/323130e242fce4de003bdde4f4b1216d3ebb30a2
new file mode 100644
index 0000000..e499ca1
Binary files /dev/null and b/regress/corpus/323130e242fce4de003bdde4f4b1216d3ebb30a2 differ
diff --git a/regress/corpus/32d43a9115ece8e3dc8569a396cfb73093247cbb b/regress/corpus/32d43a9115ece8e3dc8569a396cfb73093247cbb
new file mode 100644
index 0000000..dc6d43a
Binary files /dev/null and b/regress/corpus/32d43a9115ece8e3dc8569a396cfb73093247cbb differ
diff --git a/regress/corpus/33a9cfceb5d8066702ed804e7966bad5a7c88e04 b/regress/corpus/33a9cfceb5d8066702ed804e7966bad5a7c88e04
new file mode 100644
index 0000000..31b5f8a
Binary files /dev/null and b/regress/corpus/33a9cfceb5d8066702ed804e7966bad5a7c88e04 differ
diff --git a/regress/corpus/33beb128817667b5653409588429829b2f61224e b/regress/corpus/33beb128817667b5653409588429829b2f61224e
new file mode 100644
index 0000000..1bae4ab
Binary files /dev/null and b/regress/corpus/33beb128817667b5653409588429829b2f61224e differ
diff --git a/regress/corpus/33f8a99df3d81daa6ab63fbbbdc9e86342c5224f b/regress/corpus/33f8a99df3d81daa6ab63fbbbdc9e86342c5224f
new file mode 100644
index 0000000..82c1045
Binary files /dev/null and b/regress/corpus/33f8a99df3d81daa6ab63fbbbdc9e86342c5224f differ
diff --git a/regress/corpus/34123b3cc13aa3f9bd2ed66318bde6ababead504 b/regress/corpus/34123b3cc13aa3f9bd2ed66318bde6ababead504
new file mode 100644
index 0000000..becf69d
Binary files /dev/null and b/regress/corpus/34123b3cc13aa3f9bd2ed66318bde6ababead504 differ
diff --git a/regress/corpus/343999770b337f3a499999dfe326bbbe4d6e6866 b/regress/corpus/343999770b337f3a499999dfe326bbbe4d6e6866
new file mode 100644
index 0000000..82a1ca2
Binary files /dev/null and b/regress/corpus/343999770b337f3a499999dfe326bbbe4d6e6866 differ
diff --git a/regress/corpus/3439bb3bdf88f354e0620bad20cd2521d649c69c b/regress/corpus/3439bb3bdf88f354e0620bad20cd2521d649c69c
new file mode 100644
index 0000000..2162b18
Binary files /dev/null and b/regress/corpus/3439bb3bdf88f354e0620bad20cd2521d649c69c differ
diff --git a/regress/corpus/353358e6df47a6d8cc9770c01f416286b2e0a452 b/regress/corpus/353358e6df47a6d8cc9770c01f416286b2e0a452
new file mode 100644
index 0000000..e74ba8e
--- /dev/null
+++ b/regress/corpus/353358e6df47a6d8cc9770c01f416286b2e0a452
@@ -0,0 +1 @@
+@ÿÿ
\ No newline at end of file
diff --git a/regress/corpus/35696d71e38e278590def3e6bf935e1a2d3fac49 b/regress/corpus/35696d71e38e278590def3e6bf935e1a2d3fac49
new file mode 100644
index 0000000..dde7d19
Binary files /dev/null and b/regress/corpus/35696d71e38e278590def3e6bf935e1a2d3fac49 differ
diff --git a/regress/corpus/35899680e1250f122276fd0eedfff06031a89236 b/regress/corpus/35899680e1250f122276fd0eedfff06031a89236
new file mode 100644
index 0000000..a2e6daa
Binary files /dev/null and b/regress/corpus/35899680e1250f122276fd0eedfff06031a89236 differ
diff --git a/regress/corpus/3594bb3f4f5107d5506a5ca1013f866c39b8556a b/regress/corpus/3594bb3f4f5107d5506a5ca1013f866c39b8556a
new file mode 100644
index 0000000..0f5353d
Binary files /dev/null and b/regress/corpus/3594bb3f4f5107d5506a5ca1013f866c39b8556a differ
diff --git a/regress/corpus/35c43955fb140ff140b6e674ed21d80614675a2e b/regress/corpus/35c43955fb140ff140b6e674ed21d80614675a2e
new file mode 100644
index 0000000..16c5108
Binary files /dev/null and b/regress/corpus/35c43955fb140ff140b6e674ed21d80614675a2e differ
diff --git a/regress/corpus/35e51a411331106d14089b211a3cb0666b2142cc b/regress/corpus/35e51a411331106d14089b211a3cb0666b2142cc
new file mode 100644
index 0000000..2feb093
Binary files /dev/null and b/regress/corpus/35e51a411331106d14089b211a3cb0666b2142cc differ
diff --git a/regress/corpus/3670a2d19f299e383d9c1e90827f9bc06639196a b/regress/corpus/3670a2d19f299e383d9c1e90827f9bc06639196a
new file mode 100644
index 0000000..32a3f6e
Binary files /dev/null and b/regress/corpus/3670a2d19f299e383d9c1e90827f9bc06639196a differ
diff --git a/regress/corpus/369e2ae9ce55f43974abb54d28ebd3c68c9f93fd b/regress/corpus/369e2ae9ce55f43974abb54d28ebd3c68c9f93fd
new file mode 100644
index 0000000..87d9628
Binary files /dev/null and b/regress/corpus/369e2ae9ce55f43974abb54d28ebd3c68c9f93fd differ
diff --git a/regress/corpus/374919beb0094c593281de31eb064f5e15ffc616 b/regress/corpus/374919beb0094c593281de31eb064f5e15ffc616
new file mode 100644
index 0000000..06d0946
Binary files /dev/null and b/regress/corpus/374919beb0094c593281de31eb064f5e15ffc616 differ
diff --git a/regress/corpus/376b99801965f178f8f9b1fb5b384ab49d4a1d02 b/regress/corpus/376b99801965f178f8f9b1fb5b384ab49d4a1d02
new file mode 100644
index 0000000..611d6f6
Binary files /dev/null and b/regress/corpus/376b99801965f178f8f9b1fb5b384ab49d4a1d02 differ
diff --git a/regress/corpus/37aadc6d4e6335c87ac50b9631c9c7ffe765ca1c b/regress/corpus/37aadc6d4e6335c87ac50b9631c9c7ffe765ca1c
new file mode 100644
index 0000000..6e4f0f8
Binary files /dev/null and b/regress/corpus/37aadc6d4e6335c87ac50b9631c9c7ffe765ca1c differ
diff --git a/regress/corpus/37d15e7ccdfaf9180d54744ad215e610e1348dfc b/regress/corpus/37d15e7ccdfaf9180d54744ad215e610e1348dfc
new file mode 100644
index 0000000..6dfbb1a
Binary files /dev/null and b/regress/corpus/37d15e7ccdfaf9180d54744ad215e610e1348dfc differ
diff --git a/regress/corpus/38434a90d441a9fb09ba0fc40ce8c52043d05a05 b/regress/corpus/38434a90d441a9fb09ba0fc40ce8c52043d05a05
new file mode 100644
index 0000000..f36745f
Binary files /dev/null and b/regress/corpus/38434a90d441a9fb09ba0fc40ce8c52043d05a05 differ
diff --git a/regress/corpus/387708af8f56a45c5cdc25febd3846c15427379d b/regress/corpus/387708af8f56a45c5cdc25febd3846c15427379d
new file mode 100644
index 0000000..89f9ded
Binary files /dev/null and b/regress/corpus/387708af8f56a45c5cdc25febd3846c15427379d differ
diff --git a/regress/corpus/38944a1cbfd36341053ed8e51225571fec974d80 b/regress/corpus/38944a1cbfd36341053ed8e51225571fec974d80
new file mode 100644
index 0000000..3e9ebed
Binary files /dev/null and b/regress/corpus/38944a1cbfd36341053ed8e51225571fec974d80 differ
diff --git a/regress/corpus/396ee16d969a15a701832cec9b08b94b5b4be6bb b/regress/corpus/396ee16d969a15a701832cec9b08b94b5b4be6bb
new file mode 100644
index 0000000..d231c24
Binary files /dev/null and b/regress/corpus/396ee16d969a15a701832cec9b08b94b5b4be6bb differ
diff --git a/regress/corpus/39d643b43868b8d966ceed5a2ce8373cdbc04d52 b/regress/corpus/39d643b43868b8d966ceed5a2ce8373cdbc04d52
new file mode 100644
index 0000000..f1193d6
Binary files /dev/null and b/regress/corpus/39d643b43868b8d966ceed5a2ce8373cdbc04d52 differ
diff --git a/regress/corpus/3a6f515747bcb977194c9e66b8b59f715dce8bac b/regress/corpus/3a6f515747bcb977194c9e66b8b59f715dce8bac
new file mode 100644
index 0000000..0bc6034
Binary files /dev/null and b/regress/corpus/3a6f515747bcb977194c9e66b8b59f715dce8bac differ
diff --git a/regress/corpus/3a7d71cb363b680a99149b082301bb45f4c0b415 b/regress/corpus/3a7d71cb363b680a99149b082301bb45f4c0b415
new file mode 100644
index 0000000..508a9eb
Binary files /dev/null and b/regress/corpus/3a7d71cb363b680a99149b082301bb45f4c0b415 differ
diff --git a/regress/corpus/3a8a3fa1f75957da33929785be0fd494838e083c b/regress/corpus/3a8a3fa1f75957da33929785be0fd494838e083c
new file mode 100644
index 0000000..6c76e57
Binary files /dev/null and b/regress/corpus/3a8a3fa1f75957da33929785be0fd494838e083c differ
diff --git a/regress/corpus/3aad256bb20731d55e953a0a0680b320607e2b14 b/regress/corpus/3aad256bb20731d55e953a0a0680b320607e2b14
new file mode 100644
index 0000000..78a3467
Binary files /dev/null and b/regress/corpus/3aad256bb20731d55e953a0a0680b320607e2b14 differ
diff --git a/regress/corpus/3b15b117c64521f1bfd7ab42276c5e4d38034f59 b/regress/corpus/3b15b117c64521f1bfd7ab42276c5e4d38034f59
new file mode 100644
index 0000000..e0bfb3a
Binary files /dev/null and b/regress/corpus/3b15b117c64521f1bfd7ab42276c5e4d38034f59 differ
diff --git a/regress/corpus/3b37bc229f0357efbf916ea8fcdf42218f99bde2 b/regress/corpus/3b37bc229f0357efbf916ea8fcdf42218f99bde2
new file mode 100644
index 0000000..bd2c9b2
Binary files /dev/null and b/regress/corpus/3b37bc229f0357efbf916ea8fcdf42218f99bde2 differ
diff --git a/regress/corpus/3b48ce37cb4a9595f307da92804038b192550747 b/regress/corpus/3b48ce37cb4a9595f307da92804038b192550747
new file mode 100644
index 0000000..5d352ef
Binary files /dev/null and b/regress/corpus/3b48ce37cb4a9595f307da92804038b192550747 differ
diff --git a/regress/corpus/3c1c5e1289b14cc90748c8b1cd097dfff0c90b0e b/regress/corpus/3c1c5e1289b14cc90748c8b1cd097dfff0c90b0e
new file mode 100644
index 0000000..65afe92
Binary files /dev/null and b/regress/corpus/3c1c5e1289b14cc90748c8b1cd097dfff0c90b0e differ
diff --git a/regress/corpus/3c2e7c16a57cae362822bacbb30a9db4e1efa06c b/regress/corpus/3c2e7c16a57cae362822bacbb30a9db4e1efa06c
new file mode 100644
index 0000000..0cd6589
Binary files /dev/null and b/regress/corpus/3c2e7c16a57cae362822bacbb30a9db4e1efa06c differ
diff --git a/regress/corpus/3c5fe231aac61d6c7fff4d587d3f4cccb4d4c97a b/regress/corpus/3c5fe231aac61d6c7fff4d587d3f4cccb4d4c97a
new file mode 100644
index 0000000..f0df730
Binary files /dev/null and b/regress/corpus/3c5fe231aac61d6c7fff4d587d3f4cccb4d4c97a differ
diff --git a/regress/corpus/3c71ed87d767c058e43a2616fff6d16f1e4df38a b/regress/corpus/3c71ed87d767c058e43a2616fff6d16f1e4df38a
new file mode 100644
index 0000000..dd4f1b7
Binary files /dev/null and b/regress/corpus/3c71ed87d767c058e43a2616fff6d16f1e4df38a differ
diff --git a/regress/corpus/3c8673549c42cbaa4884640aab4896cb5e505815 b/regress/corpus/3c8673549c42cbaa4884640aab4896cb5e505815
new file mode 100644
index 0000000..ae7f296
Binary files /dev/null and b/regress/corpus/3c8673549c42cbaa4884640aab4896cb5e505815 differ
diff --git a/regress/corpus/3d9cbe2ddba62cfa3a0885add69c8ce2ab279f72 b/regress/corpus/3d9cbe2ddba62cfa3a0885add69c8ce2ab279f72
new file mode 100644
index 0000000..f61e5ba
Binary files /dev/null and b/regress/corpus/3d9cbe2ddba62cfa3a0885add69c8ce2ab279f72 differ
diff --git a/regress/corpus/3de78e062d58653c0ac406b7ad5666d6c12851f2 b/regress/corpus/3de78e062d58653c0ac406b7ad5666d6c12851f2
new file mode 100644
index 0000000..b3b7f99
--- /dev/null
+++ b/regress/corpus/3de78e062d58653c0ac406b7ad5666d6c12851f2
@@ -0,0 +1 @@
+




















55555555555555511111110




\ No newline at end of file
diff --git a/regress/corpus/3e367c8f6035bb61685ccdcd7ece2f3cd4d97cae b/regress/corpus/3e367c8f6035bb61685ccdcd7ece2f3cd4d97cae
new file mode 100644
index 0000000..79a19a9
Binary files /dev/null and b/regress/corpus/3e367c8f6035bb61685ccdcd7ece2f3cd4d97cae differ
diff --git a/regress/corpus/3e427b08d214b610fdf6a79409b1675e617500cd b/regress/corpus/3e427b08d214b610fdf6a79409b1675e617500cd
new file mode 100644
index 0000000..9269acd
Binary files /dev/null and b/regress/corpus/3e427b08d214b610fdf6a79409b1675e617500cd differ
diff --git a/regress/corpus/3e5df3a465e2700ce2a6162943e2414144903a12 b/regress/corpus/3e5df3a465e2700ce2a6162943e2414144903a12
new file mode 100644
index 0000000..e6b5b9f
Binary files /dev/null and b/regress/corpus/3e5df3a465e2700ce2a6162943e2414144903a12 differ
diff --git a/regress/corpus/3e9a73ea8210799e931e347dbae082c56ba7ac83 b/regress/corpus/3e9a73ea8210799e931e347dbae082c56ba7ac83
new file mode 100644
index 0000000..0b1d2fb
Binary files /dev/null and b/regress/corpus/3e9a73ea8210799e931e347dbae082c56ba7ac83 differ
diff --git a/regress/corpus/3f17ec086c28ca258ec15625b2e0fbd882f3b561 b/regress/corpus/3f17ec086c28ca258ec15625b2e0fbd882f3b561
new file mode 100644
index 0000000..123ed15
Binary files /dev/null and b/regress/corpus/3f17ec086c28ca258ec15625b2e0fbd882f3b561 differ
diff --git a/regress/corpus/3f29546453678b855931c174a97d6c0894b8f546 b/regress/corpus/3f29546453678b855931c174a97d6c0894b8f546
new file mode 100644
index 0000000..bdc955b
Binary files /dev/null and b/regress/corpus/3f29546453678b855931c174a97d6c0894b8f546 differ
diff --git a/regress/corpus/3f3638f72195ce50e78aa04a8a662836505989f6 b/regress/corpus/3f3638f72195ce50e78aa04a8a662836505989f6
new file mode 100644
index 0000000..1aeaa2d
Binary files /dev/null and b/regress/corpus/3f3638f72195ce50e78aa04a8a662836505989f6 differ
diff --git a/regress/corpus/3fbd827d4341b0787fec3f1696689b285d7c23b3 b/regress/corpus/3fbd827d4341b0787fec3f1696689b285d7c23b3
new file mode 100644
index 0000000..dfc689a
Binary files /dev/null and b/regress/corpus/3fbd827d4341b0787fec3f1696689b285d7c23b3 differ
diff --git a/regress/corpus/3fd61183fe5d8adda5d35a778ca52bbd3b288912 b/regress/corpus/3fd61183fe5d8adda5d35a778ca52bbd3b288912
new file mode 100644
index 0000000..c884587
Binary files /dev/null and b/regress/corpus/3fd61183fe5d8adda5d35a778ca52bbd3b288912 differ
diff --git a/regress/corpus/3fde52494ae3583a12011d1b205e60af3c716d69 b/regress/corpus/3fde52494ae3583a12011d1b205e60af3c716d69
new file mode 100644
index 0000000..c30ecd4
Binary files /dev/null and b/regress/corpus/3fde52494ae3583a12011d1b205e60af3c716d69 differ
diff --git a/regress/corpus/3ffba24e312037bf35fbf5d4b283c499eee33906 b/regress/corpus/3ffba24e312037bf35fbf5d4b283c499eee33906
new file mode 100644
index 0000000..a9c82d6
Binary files /dev/null and b/regress/corpus/3ffba24e312037bf35fbf5d4b283c499eee33906 differ
diff --git a/regress/corpus/403cf7da34f75c24898992e8dc8d014e684929ae b/regress/corpus/403cf7da34f75c24898992e8dc8d014e684929ae
new file mode 100644
index 0000000..f789ccc
Binary files /dev/null and b/regress/corpus/403cf7da34f75c24898992e8dc8d014e684929ae differ
diff --git a/regress/corpus/4040349072e187379c686d3c1e8cbb3086f6b9ee b/regress/corpus/4040349072e187379c686d3c1e8cbb3086f6b9ee
new file mode 100644
index 0000000..c02814f
Binary files /dev/null and b/regress/corpus/4040349072e187379c686d3c1e8cbb3086f6b9ee differ
diff --git a/regress/corpus/4053a862cb02dbdd9bb1c3448b7fea6952f881fc b/regress/corpus/4053a862cb02dbdd9bb1c3448b7fea6952f881fc
new file mode 100644
index 0000000..9bc00e6
Binary files /dev/null and b/regress/corpus/4053a862cb02dbdd9bb1c3448b7fea6952f881fc differ
diff --git a/regress/corpus/409ba2e2ed53e29e5e8715e68474e31235b0d48e b/regress/corpus/409ba2e2ed53e29e5e8715e68474e31235b0d48e
new file mode 100644
index 0000000..36b8ccb
Binary files /dev/null and b/regress/corpus/409ba2e2ed53e29e5e8715e68474e31235b0d48e differ
diff --git a/regress/corpus/40e42ca1cae27b745c4592353babbfdaaa072591 b/regress/corpus/40e42ca1cae27b745c4592353babbfdaaa072591
new file mode 100644
index 0000000..590cb88
Binary files /dev/null and b/regress/corpus/40e42ca1cae27b745c4592353babbfdaaa072591 differ
diff --git a/regress/corpus/41111dd31321431f1dc1fd5d2eb98b898863570c b/regress/corpus/41111dd31321431f1dc1fd5d2eb98b898863570c
new file mode 100644
index 0000000..216f7b0
Binary files /dev/null and b/regress/corpus/41111dd31321431f1dc1fd5d2eb98b898863570c differ
diff --git a/regress/corpus/4136010d05a3029994ea3bdda4398993ae871c16 b/regress/corpus/4136010d05a3029994ea3bdda4398993ae871c16
new file mode 100644
index 0000000..f49c29a
Binary files /dev/null and b/regress/corpus/4136010d05a3029994ea3bdda4398993ae871c16 differ
diff --git a/regress/corpus/414c8014455d6efe6eaaeff34784b0e2f32bc4a0 b/regress/corpus/414c8014455d6efe6eaaeff34784b0e2f32bc4a0
new file mode 100644
index 0000000..e0f66c5
Binary files /dev/null and b/regress/corpus/414c8014455d6efe6eaaeff34784b0e2f32bc4a0 differ
diff --git a/regress/corpus/416419ee5586d4b9ab69cea505e662dcdeede61a b/regress/corpus/416419ee5586d4b9ab69cea505e662dcdeede61a
new file mode 100644
index 0000000..7b4a090
Binary files /dev/null and b/regress/corpus/416419ee5586d4b9ab69cea505e662dcdeede61a differ
diff --git a/regress/corpus/41af7d0ec9cb0d57f394dd15fbb035d55d4110fc b/regress/corpus/41af7d0ec9cb0d57f394dd15fbb035d55d4110fc
new file mode 100644
index 0000000..ebe3106
Binary files /dev/null and b/regress/corpus/41af7d0ec9cb0d57f394dd15fbb035d55d4110fc differ
diff --git a/regress/corpus/41bbaa298c4c4e908a176d252144db2f9e12be19 b/regress/corpus/41bbaa298c4c4e908a176d252144db2f9e12be19
new file mode 100644
index 0000000..88d88ab
Binary files /dev/null and b/regress/corpus/41bbaa298c4c4e908a176d252144db2f9e12be19 differ
diff --git a/regress/corpus/41dfb39b5dff440cbfab4ade7fa153e874f9da77 b/regress/corpus/41dfb39b5dff440cbfab4ade7fa153e874f9da77
new file mode 100644
index 0000000..a95c461
Binary files /dev/null and b/regress/corpus/41dfb39b5dff440cbfab4ade7fa153e874f9da77 differ
diff --git a/regress/corpus/41fcef2d7b1ef7a8b1cf1aae36aa141a03ca23fc b/regress/corpus/41fcef2d7b1ef7a8b1cf1aae36aa141a03ca23fc
new file mode 100644
index 0000000..93a221f
Binary files /dev/null and b/regress/corpus/41fcef2d7b1ef7a8b1cf1aae36aa141a03ca23fc differ
diff --git a/regress/corpus/420ec67820cf8d69b8bdfb7c1a43ac382f5aa480 b/regress/corpus/420ec67820cf8d69b8bdfb7c1a43ac382f5aa480
new file mode 100644
index 0000000..28c1116
Binary files /dev/null and b/regress/corpus/420ec67820cf8d69b8bdfb7c1a43ac382f5aa480 differ
diff --git a/regress/corpus/430b873b09790ff81c2d498966c8e26a78fffd83 b/regress/corpus/430b873b09790ff81c2d498966c8e26a78fffd83
new file mode 100644
index 0000000..4adb789
Binary files /dev/null and b/regress/corpus/430b873b09790ff81c2d498966c8e26a78fffd83 differ
diff --git a/regress/corpus/4327c3d73887ceef8839dd97bb1a09e6c23e1ba9 b/regress/corpus/4327c3d73887ceef8839dd97bb1a09e6c23e1ba9
new file mode 100644
index 0000000..9ffbf89
Binary files /dev/null and b/regress/corpus/4327c3d73887ceef8839dd97bb1a09e6c23e1ba9 differ
diff --git a/regress/corpus/4371696d9dd3f15434ee62ee46726ebdd7e595b3 b/regress/corpus/4371696d9dd3f15434ee62ee46726ebdd7e595b3
new file mode 100644
index 0000000..4c1ddc4
Binary files /dev/null and b/regress/corpus/4371696d9dd3f15434ee62ee46726ebdd7e595b3 differ
diff --git a/regress/corpus/437580361f6609b9c37abe8ea3ae7c92fcf12b3f b/regress/corpus/437580361f6609b9c37abe8ea3ae7c92fcf12b3f
new file mode 100644
index 0000000..8052b24
Binary files /dev/null and b/regress/corpus/437580361f6609b9c37abe8ea3ae7c92fcf12b3f differ
diff --git a/regress/corpus/439a5209d64467e7a5873ce1bd2837d9ed47bf21 b/regress/corpus/439a5209d64467e7a5873ce1bd2837d9ed47bf21
new file mode 100644
index 0000000..fc6084c
Binary files /dev/null and b/regress/corpus/439a5209d64467e7a5873ce1bd2837d9ed47bf21 differ
diff --git a/regress/corpus/43a1a1d28b25989db93fa683946e810c26aad67d b/regress/corpus/43a1a1d28b25989db93fa683946e810c26aad67d
new file mode 100644
index 0000000..a75e5c9
Binary files /dev/null and b/regress/corpus/43a1a1d28b25989db93fa683946e810c26aad67d differ
diff --git a/regress/corpus/44226925646a23e6a65d8121e1e68fc6f901b06b b/regress/corpus/44226925646a23e6a65d8121e1e68fc6f901b06b
new file mode 100644
index 0000000..df9fdfe
Binary files /dev/null and b/regress/corpus/44226925646a23e6a65d8121e1e68fc6f901b06b differ
diff --git a/regress/corpus/450999aa78da3940ea61da0fbe7e5f2a0b249b69 b/regress/corpus/450999aa78da3940ea61da0fbe7e5f2a0b249b69
new file mode 100644
index 0000000..704c46b
Binary files /dev/null and b/regress/corpus/450999aa78da3940ea61da0fbe7e5f2a0b249b69 differ
diff --git a/regress/corpus/452c399f3b1de9df7ddf7997b6dc5abf7560c9b2 b/regress/corpus/452c399f3b1de9df7ddf7997b6dc5abf7560c9b2
new file mode 100644
index 0000000..bfa0b18
Binary files /dev/null and b/regress/corpus/452c399f3b1de9df7ddf7997b6dc5abf7560c9b2 differ
diff --git a/regress/corpus/456531b41e6297144fd28076ac8a90d1fc1f25bc b/regress/corpus/456531b41e6297144fd28076ac8a90d1fc1f25bc
new file mode 100644
index 0000000..ea32bf4
Binary files /dev/null and b/regress/corpus/456531b41e6297144fd28076ac8a90d1fc1f25bc differ
diff --git a/regress/corpus/45ad911fb32b2ac8adcce4084c2242b155875dd9 b/regress/corpus/45ad911fb32b2ac8adcce4084c2242b155875dd9
new file mode 100644
index 0000000..61c6527
Binary files /dev/null and b/regress/corpus/45ad911fb32b2ac8adcce4084c2242b155875dd9 differ
diff --git a/regress/corpus/465ec4eb5355089baf90ed356f10f0bc4169714d b/regress/corpus/465ec4eb5355089baf90ed356f10f0bc4169714d
new file mode 100644
index 0000000..f46bc9e
Binary files /dev/null and b/regress/corpus/465ec4eb5355089baf90ed356f10f0bc4169714d differ
diff --git a/regress/corpus/46ac6922e7ada864406f345d4be63c8a125f844f b/regress/corpus/46ac6922e7ada864406f345d4be63c8a125f844f
new file mode 100644
index 0000000..15efdd8
Binary files /dev/null and b/regress/corpus/46ac6922e7ada864406f345d4be63c8a125f844f differ
diff --git a/regress/corpus/46c2c633ccb9d653a3d620005fde492fe0fa2850 b/regress/corpus/46c2c633ccb9d653a3d620005fde492fe0fa2850
new file mode 100644
index 0000000..7515c1c
Binary files /dev/null and b/regress/corpus/46c2c633ccb9d653a3d620005fde492fe0fa2850 differ
diff --git a/regress/corpus/46d8e80b2acb4a6e2d8dcb622e08a4549d178313 b/regress/corpus/46d8e80b2acb4a6e2d8dcb622e08a4549d178313
new file mode 100644
index 0000000..da37a57
Binary files /dev/null and b/regress/corpus/46d8e80b2acb4a6e2d8dcb622e08a4549d178313 differ
diff --git a/regress/corpus/46f57c86aef859e7d9ef0d1485309620adf49399 b/regress/corpus/46f57c86aef859e7d9ef0d1485309620adf49399
new file mode 100644
index 0000000..aa7634e
Binary files /dev/null and b/regress/corpus/46f57c86aef859e7d9ef0d1485309620adf49399 differ
diff --git a/regress/corpus/472f588cf5df3c6cbfb43291078b064f9c359abe b/regress/corpus/472f588cf5df3c6cbfb43291078b064f9c359abe
new file mode 100644
index 0000000..c35eb7a
Binary files /dev/null and b/regress/corpus/472f588cf5df3c6cbfb43291078b064f9c359abe differ
diff --git a/regress/corpus/477f5787adb4d21b2b0237a7c38dd77f449bc7fb b/regress/corpus/477f5787adb4d21b2b0237a7c38dd77f449bc7fb
new file mode 100644
index 0000000..af20ece
Binary files /dev/null and b/regress/corpus/477f5787adb4d21b2b0237a7c38dd77f449bc7fb differ
diff --git a/regress/corpus/478785a17da604376f797dc6eff05184417a0b54 b/regress/corpus/478785a17da604376f797dc6eff05184417a0b54
new file mode 100644
index 0000000..ac6633a
Binary files /dev/null and b/regress/corpus/478785a17da604376f797dc6eff05184417a0b54 differ
diff --git a/regress/corpus/478f83036019e76cc3c0b3e23052506e20c40017 b/regress/corpus/478f83036019e76cc3c0b3e23052506e20c40017
new file mode 100644
index 0000000..1e2f481
Binary files /dev/null and b/regress/corpus/478f83036019e76cc3c0b3e23052506e20c40017 differ
diff --git a/regress/corpus/47f3a312cb3e649d16181819cd8917596141c206 b/regress/corpus/47f3a312cb3e649d16181819cd8917596141c206
new file mode 100644
index 0000000..0effca8
Binary files /dev/null and b/regress/corpus/47f3a312cb3e649d16181819cd8917596141c206 differ
diff --git a/regress/corpus/47fd81f52f47ce828d8c0533f118a0ea0948b19d b/regress/corpus/47fd81f52f47ce828d8c0533f118a0ea0948b19d
new file mode 100644
index 0000000..53dd897
Binary files /dev/null and b/regress/corpus/47fd81f52f47ce828d8c0533f118a0ea0948b19d differ
diff --git a/regress/corpus/4850e15262fa334e073a4253578816b2bb0c56c9 b/regress/corpus/4850e15262fa334e073a4253578816b2bb0c56c9
new file mode 100644
index 0000000..0399d70
Binary files /dev/null and b/regress/corpus/4850e15262fa334e073a4253578816b2bb0c56c9 differ
diff --git a/regress/corpus/48c4ee21f4b7927ab2e85cbc4de7223ec7eb5a1e b/regress/corpus/48c4ee21f4b7927ab2e85cbc4de7223ec7eb5a1e
new file mode 100644
index 0000000..b7f6a66
Binary files /dev/null and b/regress/corpus/48c4ee21f4b7927ab2e85cbc4de7223ec7eb5a1e differ
diff --git a/regress/corpus/494765e4523067c1445d1bc6bf03027d613ba080 b/regress/corpus/494765e4523067c1445d1bc6bf03027d613ba080
new file mode 100644
index 0000000..0d96d12
Binary files /dev/null and b/regress/corpus/494765e4523067c1445d1bc6bf03027d613ba080 differ
diff --git a/regress/corpus/49bfceb44abb0c7297be4dd3e6112d414c8446f9 b/regress/corpus/49bfceb44abb0c7297be4dd3e6112d414c8446f9
new file mode 100644
index 0000000..9309d37
Binary files /dev/null and b/regress/corpus/49bfceb44abb0c7297be4dd3e6112d414c8446f9 differ
diff --git a/regress/corpus/4a3ab300527016b3ab40d3e45e5c3da855684281 b/regress/corpus/4a3ab300527016b3ab40d3e45e5c3da855684281
new file mode 100644
index 0000000..f52db54
Binary files /dev/null and b/regress/corpus/4a3ab300527016b3ab40d3e45e5c3da855684281 differ
diff --git a/regress/corpus/4b7c99324f541b8de76a037bf539db036ecb5c0d b/regress/corpus/4b7c99324f541b8de76a037bf539db036ecb5c0d
new file mode 100644
index 0000000..a1aa3fb
Binary files /dev/null and b/regress/corpus/4b7c99324f541b8de76a037bf539db036ecb5c0d differ
diff --git a/regress/corpus/4b82f13d0261c97e52d05578f58c32a483cb1080 b/regress/corpus/4b82f13d0261c97e52d05578f58c32a483cb1080
new file mode 100644
index 0000000..0f7421e
Binary files /dev/null and b/regress/corpus/4b82f13d0261c97e52d05578f58c32a483cb1080 differ
diff --git a/regress/corpus/4b9e269275a55dd3718d4b7260e8bde518d7ca8f b/regress/corpus/4b9e269275a55dd3718d4b7260e8bde518d7ca8f
new file mode 100644
index 0000000..e7d9e02
Binary files /dev/null and b/regress/corpus/4b9e269275a55dd3718d4b7260e8bde518d7ca8f differ
diff --git a/regress/corpus/4c010fbd8a725d0601876f99dfc135f3dfaaf6e0 b/regress/corpus/4c010fbd8a725d0601876f99dfc135f3dfaaf6e0
new file mode 100644
index 0000000..9acf56b
Binary files /dev/null and b/regress/corpus/4c010fbd8a725d0601876f99dfc135f3dfaaf6e0 differ
diff --git a/regress/corpus/4c2a3b02fe388a78aacfb64954f51f25f6b9004a b/regress/corpus/4c2a3b02fe388a78aacfb64954f51f25f6b9004a
new file mode 100644
index 0000000..68564d6
Binary files /dev/null and b/regress/corpus/4c2a3b02fe388a78aacfb64954f51f25f6b9004a differ
diff --git a/regress/corpus/4ca009cb61058d218961250f06eda171703cec6e b/regress/corpus/4ca009cb61058d218961250f06eda171703cec6e
new file mode 100644
index 0000000..6429e6e
Binary files /dev/null and b/regress/corpus/4ca009cb61058d218961250f06eda171703cec6e differ
diff --git a/regress/corpus/4d1187db31c91f844105ba3f4c00b611464e3560 b/regress/corpus/4d1187db31c91f844105ba3f4c00b611464e3560
new file mode 100644
index 0000000..ea6938d
Binary files /dev/null and b/regress/corpus/4d1187db31c91f844105ba3f4c00b611464e3560 differ
diff --git a/regress/corpus/4d4f0a4b1922c193d4e00b1948d4e17c36a9a54b b/regress/corpus/4d4f0a4b1922c193d4e00b1948d4e17c36a9a54b
new file mode 100644
index 0000000..5b70c19
Binary files /dev/null and b/regress/corpus/4d4f0a4b1922c193d4e00b1948d4e17c36a9a54b differ
diff --git a/regress/corpus/4d53c24fb69b4154d35d991464bb1fd4fc9c340d b/regress/corpus/4d53c24fb69b4154d35d991464bb1fd4fc9c340d
new file mode 100644
index 0000000..f1d4276
Binary files /dev/null and b/regress/corpus/4d53c24fb69b4154d35d991464bb1fd4fc9c340d differ
diff --git a/regress/corpus/4d87c37fc5fbd65616fe0a662f8df73d105978e0 b/regress/corpus/4d87c37fc5fbd65616fe0a662f8df73d105978e0
new file mode 100644
index 0000000..079aeae
Binary files /dev/null and b/regress/corpus/4d87c37fc5fbd65616fe0a662f8df73d105978e0 differ
diff --git a/regress/corpus/4db8caf3dc4b08ec5d98c0068bb3874dda1f7f2e b/regress/corpus/4db8caf3dc4b08ec5d98c0068bb3874dda1f7f2e
new file mode 100644
index 0000000..b8c2d7c
Binary files /dev/null and b/regress/corpus/4db8caf3dc4b08ec5d98c0068bb3874dda1f7f2e differ
diff --git a/regress/corpus/4dfbf879811b5c5ee4d7ec834380f589e0548e5d b/regress/corpus/4dfbf879811b5c5ee4d7ec834380f589e0548e5d
new file mode 100644
index 0000000..77084eb
Binary files /dev/null and b/regress/corpus/4dfbf879811b5c5ee4d7ec834380f589e0548e5d differ
diff --git a/regress/corpus/4e5a1ffb56c47434ad5d4d3f9ebd5cac5edcc005 b/regress/corpus/4e5a1ffb56c47434ad5d4d3f9ebd5cac5edcc005
new file mode 100644
index 0000000..9728526
Binary files /dev/null and b/regress/corpus/4e5a1ffb56c47434ad5d4d3f9ebd5cac5edcc005 differ
diff --git a/regress/corpus/4efd1e41cab142b1e6afb87aff4a93564bb77fd9 b/regress/corpus/4efd1e41cab142b1e6afb87aff4a93564bb77fd9
new file mode 100644
index 0000000..ed416ab
Binary files /dev/null and b/regress/corpus/4efd1e41cab142b1e6afb87aff4a93564bb77fd9 differ
diff --git a/regress/corpus/503b977b6297628ae89b78b54f534204e512854c b/regress/corpus/503b977b6297628ae89b78b54f534204e512854c
new file mode 100644
index 0000000..07e25f2
Binary files /dev/null and b/regress/corpus/503b977b6297628ae89b78b54f534204e512854c differ
diff --git a/regress/corpus/5048c10afb16a0693a8bbddab9a0f9978cc4a43d b/regress/corpus/5048c10afb16a0693a8bbddab9a0f9978cc4a43d
new file mode 100644
index 0000000..e6ac0dc
Binary files /dev/null and b/regress/corpus/5048c10afb16a0693a8bbddab9a0f9978cc4a43d differ
diff --git a/regress/corpus/505d58d5145be782cd069ed73e63f72f2cee2e4b b/regress/corpus/505d58d5145be782cd069ed73e63f72f2cee2e4b
new file mode 100644
index 0000000..94d0b8b
Binary files /dev/null and b/regress/corpus/505d58d5145be782cd069ed73e63f72f2cee2e4b differ
diff --git a/regress/corpus/506c6c22bd683b008ac5954e457970f18efd9aad b/regress/corpus/506c6c22bd683b008ac5954e457970f18efd9aad
new file mode 100644
index 0000000..54335cd
Binary files /dev/null and b/regress/corpus/506c6c22bd683b008ac5954e457970f18efd9aad differ
diff --git a/regress/corpus/50addb836a7dcf9a25dd60ef4e6369f2c8428510 b/regress/corpus/50addb836a7dcf9a25dd60ef4e6369f2c8428510
new file mode 100644
index 0000000..d4f6de9
Binary files /dev/null and b/regress/corpus/50addb836a7dcf9a25dd60ef4e6369f2c8428510 differ
diff --git a/regress/corpus/50e2916c5be01c43e754b837af7e3256d552f634 b/regress/corpus/50e2916c5be01c43e754b837af7e3256d552f634
new file mode 100644
index 0000000..0ff02e3
Binary files /dev/null and b/regress/corpus/50e2916c5be01c43e754b837af7e3256d552f634 differ
diff --git a/regress/corpus/51933a06404987f125e5635ddf28809219a2a68e b/regress/corpus/51933a06404987f125e5635ddf28809219a2a68e
new file mode 100644
index 0000000..80b7f19
Binary files /dev/null and b/regress/corpus/51933a06404987f125e5635ddf28809219a2a68e differ
diff --git a/regress/corpus/51f3926eddddf8d937701dc54ec7361945095d75 b/regress/corpus/51f3926eddddf8d937701dc54ec7361945095d75
new file mode 100644
index 0000000..77a4eb5
Binary files /dev/null and b/regress/corpus/51f3926eddddf8d937701dc54ec7361945095d75 differ
diff --git a/regress/corpus/520876e4a0798f53fbcdb44de7733864f8bb31c1 b/regress/corpus/520876e4a0798f53fbcdb44de7733864f8bb31c1
new file mode 100644
index 0000000..7e79897
Binary files /dev/null and b/regress/corpus/520876e4a0798f53fbcdb44de7733864f8bb31c1 differ
diff --git a/regress/corpus/528f3f39bf96344450824170379820aefa897ce4 b/regress/corpus/528f3f39bf96344450824170379820aefa897ce4
new file mode 100644
index 0000000..3d18b75
Binary files /dev/null and b/regress/corpus/528f3f39bf96344450824170379820aefa897ce4 differ
diff --git a/regress/corpus/5297f5bcca807013f3df83dff5b9a6b0ac71cbc0 b/regress/corpus/5297f5bcca807013f3df83dff5b9a6b0ac71cbc0
new file mode 100644
index 0000000..7635053
Binary files /dev/null and b/regress/corpus/5297f5bcca807013f3df83dff5b9a6b0ac71cbc0 differ
diff --git a/regress/corpus/52a3a2f80decc02786a8e697ded3f52fd60247e7 b/regress/corpus/52a3a2f80decc02786a8e697ded3f52fd60247e7
new file mode 100644
index 0000000..8d6c630
Binary files /dev/null and b/regress/corpus/52a3a2f80decc02786a8e697ded3f52fd60247e7 differ
diff --git a/regress/corpus/52ad877c0637876464e28a3799fffd6c0d22637e b/regress/corpus/52ad877c0637876464e28a3799fffd6c0d22637e
new file mode 100644
index 0000000..c1b0158
Binary files /dev/null and b/regress/corpus/52ad877c0637876464e28a3799fffd6c0d22637e differ
diff --git a/regress/corpus/53151ae8707aadedf24369e09b8e3e77556883aa b/regress/corpus/53151ae8707aadedf24369e09b8e3e77556883aa
new file mode 100644
index 0000000..cc33010
Binary files /dev/null and b/regress/corpus/53151ae8707aadedf24369e09b8e3e77556883aa differ
diff --git a/regress/corpus/5337ce6fa8186d7b28fc0fcf3953a20054ae0590 b/regress/corpus/5337ce6fa8186d7b28fc0fcf3953a20054ae0590
new file mode 100644
index 0000000..aa0dd5a
Binary files /dev/null and b/regress/corpus/5337ce6fa8186d7b28fc0fcf3953a20054ae0590 differ
diff --git a/regress/corpus/53647029f5b00dbd95987a6041d9386770184b98 b/regress/corpus/53647029f5b00dbd95987a6041d9386770184b98
new file mode 100644
index 0000000..49aaf90
Binary files /dev/null and b/regress/corpus/53647029f5b00dbd95987a6041d9386770184b98 differ
diff --git a/regress/corpus/53818235b41ffa5cac687b6c54c5ec447a2a0a3b b/regress/corpus/53818235b41ffa5cac687b6c54c5ec447a2a0a3b
new file mode 100644
index 0000000..ee81a77
Binary files /dev/null and b/regress/corpus/53818235b41ffa5cac687b6c54c5ec447a2a0a3b differ
diff --git a/regress/corpus/53a7ed131142efdf699ae848cd598d153059d529 b/regress/corpus/53a7ed131142efdf699ae848cd598d153059d529
new file mode 100644
index 0000000..698a5ee
Binary files /dev/null and b/regress/corpus/53a7ed131142efdf699ae848cd598d153059d529 differ
diff --git a/regress/corpus/547512fb601c3b4f86a43cbf47fcbc26b013ef4f b/regress/corpus/547512fb601c3b4f86a43cbf47fcbc26b013ef4f
new file mode 100644
index 0000000..18fbdeb
Binary files /dev/null and b/regress/corpus/547512fb601c3b4f86a43cbf47fcbc26b013ef4f differ
diff --git a/regress/corpus/558f1a2f8334085ef746479aa4201756f536cd8e b/regress/corpus/558f1a2f8334085ef746479aa4201756f536cd8e
new file mode 100644
index 0000000..89e828e
Binary files /dev/null and b/regress/corpus/558f1a2f8334085ef746479aa4201756f536cd8e differ
diff --git a/regress/corpus/5659edb82c844fa1dc9d9b59102534901a99064a b/regress/corpus/5659edb82c844fa1dc9d9b59102534901a99064a
new file mode 100644
index 0000000..e97f207
Binary files /dev/null and b/regress/corpus/5659edb82c844fa1dc9d9b59102534901a99064a differ
diff --git a/regress/corpus/565b85391db489a5169818ec6fba4cd56b57345d b/regress/corpus/565b85391db489a5169818ec6fba4cd56b57345d
new file mode 100644
index 0000000..2e05ebe
--- /dev/null
+++ b/regress/corpus/565b85391db489a5169818ec6fba4cd56b57345d
@@ -0,0 +1 @@
+n�ž
'
\ No newline at end of file
diff --git a/regress/corpus/5685e9ddfd19bda07419cd21d034ad3fe1f86627 b/regress/corpus/5685e9ddfd19bda07419cd21d034ad3fe1f86627
new file mode 100644
index 0000000..820377c
Binary files /dev/null and b/regress/corpus/5685e9ddfd19bda07419cd21d034ad3fe1f86627 differ
diff --git a/regress/corpus/5695350604df54fb966a5a3ccd067eb69a2139bb b/regress/corpus/5695350604df54fb966a5a3ccd067eb69a2139bb
new file mode 100644
index 0000000..ce0708d
Binary files /dev/null and b/regress/corpus/5695350604df54fb966a5a3ccd067eb69a2139bb differ
diff --git a/regress/corpus/569dc5ef0dff05d8388303623d99bf254e1df0b1 b/regress/corpus/569dc5ef0dff05d8388303623d99bf254e1df0b1
new file mode 100644
index 0000000..c91a953
Binary files /dev/null and b/regress/corpus/569dc5ef0dff05d8388303623d99bf254e1df0b1 differ
diff --git a/regress/corpus/56e888ae9db53f2bcba04c4be287530733771bdf b/regress/corpus/56e888ae9db53f2bcba04c4be287530733771bdf
new file mode 100644
index 0000000..bbfb76b
Binary files /dev/null and b/regress/corpus/56e888ae9db53f2bcba04c4be287530733771bdf differ
diff --git a/regress/corpus/578d6bc5e168960b32f42af3c80347f4bfa93ca7 b/regress/corpus/578d6bc5e168960b32f42af3c80347f4bfa93ca7
new file mode 100644
index 0000000..33d0128
Binary files /dev/null and b/regress/corpus/578d6bc5e168960b32f42af3c80347f4bfa93ca7 differ
diff --git a/regress/corpus/57af095ee9c6d3ae45606be39e06459a835cde21 b/regress/corpus/57af095ee9c6d3ae45606be39e06459a835cde21
new file mode 100644
index 0000000..22198c0
Binary files /dev/null and b/regress/corpus/57af095ee9c6d3ae45606be39e06459a835cde21 differ
diff --git a/regress/corpus/57b025a38356fb63887e64b370b94df81c0d6f12 b/regress/corpus/57b025a38356fb63887e64b370b94df81c0d6f12
new file mode 100644
index 0000000..5a433c4
Binary files /dev/null and b/regress/corpus/57b025a38356fb63887e64b370b94df81c0d6f12 differ
diff --git a/regress/corpus/57ebc68efa336dee0855abfca90000adc3a63225 b/regress/corpus/57ebc68efa336dee0855abfca90000adc3a63225
new file mode 100644
index 0000000..a2f9718
Binary files /dev/null and b/regress/corpus/57ebc68efa336dee0855abfca90000adc3a63225 differ
diff --git a/regress/corpus/58432e8caa9073eb13b4ddf888aa01e6ebb72859 b/regress/corpus/58432e8caa9073eb13b4ddf888aa01e6ebb72859
new file mode 100644
index 0000000..1f08b80
Binary files /dev/null and b/regress/corpus/58432e8caa9073eb13b4ddf888aa01e6ebb72859 differ
diff --git a/regress/corpus/5870e4c340234a88cbac85c980e8fe1ea9426575 b/regress/corpus/5870e4c340234a88cbac85c980e8fe1ea9426575
new file mode 100644
index 0000000..1dad259
Binary files /dev/null and b/regress/corpus/5870e4c340234a88cbac85c980e8fe1ea9426575 differ
diff --git a/regress/corpus/59345a7d132a37299c0e8907de77992577e6114b b/regress/corpus/59345a7d132a37299c0e8907de77992577e6114b
new file mode 100644
index 0000000..480e6ec
Binary files /dev/null and b/regress/corpus/59345a7d132a37299c0e8907de77992577e6114b differ
diff --git a/regress/corpus/59407f3c78544be096fe7af58c65d1fc366aeeba b/regress/corpus/59407f3c78544be096fe7af58c65d1fc366aeeba
new file mode 100644
index 0000000..cd355d3
Binary files /dev/null and b/regress/corpus/59407f3c78544be096fe7af58c65d1fc366aeeba differ
diff --git a/regress/corpus/594c32a7ee11f5ff19dc39d622aef71760953c2b b/regress/corpus/594c32a7ee11f5ff19dc39d622aef71760953c2b
new file mode 100644
index 0000000..2f02b46
--- /dev/null
+++ b/regress/corpus/594c32a7ee11f5ff19dc39d622aef71760953c2b
@@ -0,0 +1 @@
+


































\ No newline at end of file
diff --git a/regress/corpus/597ccc89815aa8e4b4b850d8d9f7f0311825c908 b/regress/corpus/597ccc89815aa8e4b4b850d8d9f7f0311825c908
new file mode 100644
index 0000000..b3f0743
Binary files /dev/null and b/regress/corpus/597ccc89815aa8e4b4b850d8d9f7f0311825c908 differ
diff --git a/regress/corpus/59c240b944c37af855f6f88debfd3808d8d0f120 b/regress/corpus/59c240b944c37af855f6f88debfd3808d8d0f120
new file mode 100644
index 0000000..d99c657
Binary files /dev/null and b/regress/corpus/59c240b944c37af855f6f88debfd3808d8d0f120 differ
diff --git a/regress/corpus/59c3abb7de3cd82d28502a8de870089d04b7822a b/regress/corpus/59c3abb7de3cd82d28502a8de870089d04b7822a
new file mode 100644
index 0000000..bfbc45c
Binary files /dev/null and b/regress/corpus/59c3abb7de3cd82d28502a8de870089d04b7822a differ
diff --git a/regress/corpus/59ce67752c13c9db5ac85c842487299e08c683a1 b/regress/corpus/59ce67752c13c9db5ac85c842487299e08c683a1
new file mode 100644
index 0000000..5a62d33
Binary files /dev/null and b/regress/corpus/59ce67752c13c9db5ac85c842487299e08c683a1 differ
diff --git a/regress/corpus/59f1a5d9bcde6cd43cc683f888182099c672870c b/regress/corpus/59f1a5d9bcde6cd43cc683f888182099c672870c
new file mode 100644
index 0000000..a19cdeb
Binary files /dev/null and b/regress/corpus/59f1a5d9bcde6cd43cc683f888182099c672870c differ
diff --git a/regress/corpus/5a2908e3a8dc79e205c927a28a4d2bfe005e1d1a b/regress/corpus/5a2908e3a8dc79e205c927a28a4d2bfe005e1d1a
new file mode 100644
index 0000000..64c46ee
Binary files /dev/null and b/regress/corpus/5a2908e3a8dc79e205c927a28a4d2bfe005e1d1a differ
diff --git a/regress/corpus/5a4a857994bf30df1002bd2fe3a2402b9823791a b/regress/corpus/5a4a857994bf30df1002bd2fe3a2402b9823791a
new file mode 100644
index 0000000..d6723ae
Binary files /dev/null and b/regress/corpus/5a4a857994bf30df1002bd2fe3a2402b9823791a differ
diff --git a/regress/corpus/5aa0eb7787db2622efbb2c768289a7459c44a1ef b/regress/corpus/5aa0eb7787db2622efbb2c768289a7459c44a1ef
new file mode 100644
index 0000000..3a473d1
Binary files /dev/null and b/regress/corpus/5aa0eb7787db2622efbb2c768289a7459c44a1ef differ
diff --git a/regress/corpus/5af8b2bd01fb3dab8c37997f821565468643ca20 b/regress/corpus/5af8b2bd01fb3dab8c37997f821565468643ca20
new file mode 100644
index 0000000..f8738c8
Binary files /dev/null and b/regress/corpus/5af8b2bd01fb3dab8c37997f821565468643ca20 differ
diff --git a/regress/corpus/5b022069e069ef9718f3bfa6f60c76a26d83b86f b/regress/corpus/5b022069e069ef9718f3bfa6f60c76a26d83b86f
new file mode 100644
index 0000000..dcbab9d
Binary files /dev/null and b/regress/corpus/5b022069e069ef9718f3bfa6f60c76a26d83b86f differ
diff --git a/regress/corpus/5b247e387294b0b6484fa540ab5f61fd765fe849 b/regress/corpus/5b247e387294b0b6484fa540ab5f61fd765fe849
new file mode 100644
index 0000000..98b00da
Binary files /dev/null and b/regress/corpus/5b247e387294b0b6484fa540ab5f61fd765fe849 differ
diff --git a/regress/corpus/5b61943f202c580beadc67bf46dbcd3d239461a0 b/regress/corpus/5b61943f202c580beadc67bf46dbcd3d239461a0
new file mode 100644
index 0000000..6a78da7
Binary files /dev/null and b/regress/corpus/5b61943f202c580beadc67bf46dbcd3d239461a0 differ
diff --git a/regress/corpus/5bd5a2986367a6efcfa6029bdc083239c39bbb4e b/regress/corpus/5bd5a2986367a6efcfa6029bdc083239c39bbb4e
new file mode 100644
index 0000000..c457e62
Binary files /dev/null and b/regress/corpus/5bd5a2986367a6efcfa6029bdc083239c39bbb4e differ
diff --git a/regress/corpus/5bf90c32b350a9af04172ae830463243937c08d0 b/regress/corpus/5bf90c32b350a9af04172ae830463243937c08d0
new file mode 100644
index 0000000..5761824
Binary files /dev/null and b/regress/corpus/5bf90c32b350a9af04172ae830463243937c08d0 differ
diff --git a/regress/corpus/5c1180df983c912d7ead3971b9dbece4b0b6e8f3 b/regress/corpus/5c1180df983c912d7ead3971b9dbece4b0b6e8f3
new file mode 100644
index 0000000..b0c9de6
Binary files /dev/null and b/regress/corpus/5c1180df983c912d7ead3971b9dbece4b0b6e8f3 differ
diff --git a/regress/corpus/5c8e6bb767ae83a155461c99e4817616d455d647 b/regress/corpus/5c8e6bb767ae83a155461c99e4817616d455d647
new file mode 100644
index 0000000..42630fa
Binary files /dev/null and b/regress/corpus/5c8e6bb767ae83a155461c99e4817616d455d647 differ
diff --git a/regress/corpus/5d77f8eb5958f734bc9e9463f86ef9a028156ad5 b/regress/corpus/5d77f8eb5958f734bc9e9463f86ef9a028156ad5
new file mode 100644
index 0000000..d54a8b4
Binary files /dev/null and b/regress/corpus/5d77f8eb5958f734bc9e9463f86ef9a028156ad5 differ
diff --git a/regress/corpus/5d7cbd9a82cc27ed30b29d85cb66a7ca1f1ae690 b/regress/corpus/5d7cbd9a82cc27ed30b29d85cb66a7ca1f1ae690
new file mode 100644
index 0000000..b416776
Binary files /dev/null and b/regress/corpus/5d7cbd9a82cc27ed30b29d85cb66a7ca1f1ae690 differ
diff --git a/regress/corpus/5d8b6e6042fdd6adca49056e4f3a3e2399cfe951 b/regress/corpus/5d8b6e6042fdd6adca49056e4f3a3e2399cfe951
new file mode 100644
index 0000000..3280bc2
Binary files /dev/null and b/regress/corpus/5d8b6e6042fdd6adca49056e4f3a3e2399cfe951 differ
diff --git a/regress/corpus/5df46fe5c4e36ddbd1daf17e2824208af2310e0d b/regress/corpus/5df46fe5c4e36ddbd1daf17e2824208af2310e0d
new file mode 100644
index 0000000..8737394
Binary files /dev/null and b/regress/corpus/5df46fe5c4e36ddbd1daf17e2824208af2310e0d differ
diff --git a/regress/corpus/5e34d048165ad93dfbc584b4575d5ac628ae552b b/regress/corpus/5e34d048165ad93dfbc584b4575d5ac628ae552b
new file mode 100644
index 0000000..aee926f
Binary files /dev/null and b/regress/corpus/5e34d048165ad93dfbc584b4575d5ac628ae552b differ
diff --git a/regress/corpus/5e884b02b4c32c994f64b293690e5d2e16bf4d6d b/regress/corpus/5e884b02b4c32c994f64b293690e5d2e16bf4d6d
new file mode 100644
index 0000000..4c24fac
Binary files /dev/null and b/regress/corpus/5e884b02b4c32c994f64b293690e5d2e16bf4d6d differ
diff --git a/regress/corpus/5f90a4458d6d7c84a60bcf54bf81636d2d2f0216 b/regress/corpus/5f90a4458d6d7c84a60bcf54bf81636d2d2f0216
new file mode 100644
index 0000000..96d19c7
Binary files /dev/null and b/regress/corpus/5f90a4458d6d7c84a60bcf54bf81636d2d2f0216 differ
diff --git a/regress/corpus/5faf5ae7d62709a5a7948fb95dc8b7ba57bb1a43 b/regress/corpus/5faf5ae7d62709a5a7948fb95dc8b7ba57bb1a43
new file mode 100644
index 0000000..0376b28
Binary files /dev/null and b/regress/corpus/5faf5ae7d62709a5a7948fb95dc8b7ba57bb1a43 differ
diff --git a/regress/corpus/6020ced5cc1d82529e9a1bb9a64e0a50f33a47cf b/regress/corpus/6020ced5cc1d82529e9a1bb9a64e0a50f33a47cf
new file mode 100644
index 0000000..4c4cdb8
Binary files /dev/null and b/regress/corpus/6020ced5cc1d82529e9a1bb9a64e0a50f33a47cf differ
diff --git a/regress/corpus/602a45bf91fc84f84ff0e6b9595b8be0bab4aa6a b/regress/corpus/602a45bf91fc84f84ff0e6b9595b8be0bab4aa6a
new file mode 100644
index 0000000..b6c88a5
--- /dev/null
+++ b/regress/corpus/602a45bf91fc84f84ff0e6b9595b8be0bab4aa6a
@@ -0,0 +1 @@
+‹‹'
\ No newline at end of file
diff --git a/regress/corpus/605abc95e88752903094cb7a2f91c9af75bef30f b/regress/corpus/605abc95e88752903094cb7a2f91c9af75bef30f
new file mode 100644
index 0000000..8f6f2c7
Binary files /dev/null and b/regress/corpus/605abc95e88752903094cb7a2f91c9af75bef30f differ
diff --git a/regress/corpus/60842c500584fa4df9b72d7ac1a370e2d89bc531 b/regress/corpus/60842c500584fa4df9b72d7ac1a370e2d89bc531
new file mode 100644
index 0000000..5dacc30
Binary files /dev/null and b/regress/corpus/60842c500584fa4df9b72d7ac1a370e2d89bc531 differ
diff --git a/regress/corpus/60d6da387a443192250cca1eabb0e25ea816bf17 b/regress/corpus/60d6da387a443192250cca1eabb0e25ea816bf17
new file mode 100644
index 0000000..c16094b
Binary files /dev/null and b/regress/corpus/60d6da387a443192250cca1eabb0e25ea816bf17 differ
diff --git a/regress/corpus/60d71059ef39121ac5b6a3c4ecb288367e687a06 b/regress/corpus/60d71059ef39121ac5b6a3c4ecb288367e687a06
new file mode 100644
index 0000000..fc478db
Binary files /dev/null and b/regress/corpus/60d71059ef39121ac5b6a3c4ecb288367e687a06 differ
diff --git a/regress/corpus/61646a48189ef92b8923b84438ad679a4ae2d89c b/regress/corpus/61646a48189ef92b8923b84438ad679a4ae2d89c
new file mode 100644
index 0000000..4772b02
Binary files /dev/null and b/regress/corpus/61646a48189ef92b8923b84438ad679a4ae2d89c differ
diff --git a/regress/corpus/616ebc341f05110c6dbae1dbca2981639b5a44a9 b/regress/corpus/616ebc341f05110c6dbae1dbca2981639b5a44a9
new file mode 100644
index 0000000..9c5576c
Binary files /dev/null and b/regress/corpus/616ebc341f05110c6dbae1dbca2981639b5a44a9 differ
diff --git a/regress/corpus/61ffae70f2829d73ddcf01e7d64e4a8c120fb5fa b/regress/corpus/61ffae70f2829d73ddcf01e7d64e4a8c120fb5fa
new file mode 100644
index 0000000..be51713
Binary files /dev/null and b/regress/corpus/61ffae70f2829d73ddcf01e7d64e4a8c120fb5fa differ
diff --git a/regress/corpus/625b2be1dbcf6d4d77fd428151f36e305e44064a b/regress/corpus/625b2be1dbcf6d4d77fd428151f36e305e44064a
new file mode 100644
index 0000000..86d1762
Binary files /dev/null and b/regress/corpus/625b2be1dbcf6d4d77fd428151f36e305e44064a differ
diff --git a/regress/corpus/629b78008d2b9cbbab702f225f1036ee8ab7ca7b b/regress/corpus/629b78008d2b9cbbab702f225f1036ee8ab7ca7b
new file mode 100644
index 0000000..4cdc06b
Binary files /dev/null and b/regress/corpus/629b78008d2b9cbbab702f225f1036ee8ab7ca7b differ
diff --git a/regress/corpus/62c4ae6a2c238f2bc3fc4e18a4d83c56da6dc879 b/regress/corpus/62c4ae6a2c238f2bc3fc4e18a4d83c56da6dc879
new file mode 100644
index 0000000..9c7839c
Binary files /dev/null and b/regress/corpus/62c4ae6a2c238f2bc3fc4e18a4d83c56da6dc879 differ
diff --git a/regress/corpus/62e58c4e5c4445f25e828748f9651c02a83b4017 b/regress/corpus/62e58c4e5c4445f25e828748f9651c02a83b4017
new file mode 100644
index 0000000..fff8a1a
Binary files /dev/null and b/regress/corpus/62e58c4e5c4445f25e828748f9651c02a83b4017 differ
diff --git a/regress/corpus/630025e5f166c739a983ac459540067d7742d44c b/regress/corpus/630025e5f166c739a983ac459540067d7742d44c
new file mode 100644
index 0000000..87668aa
Binary files /dev/null and b/regress/corpus/630025e5f166c739a983ac459540067d7742d44c differ
diff --git a/regress/corpus/634d1bea6a04431b1da127374fcce4a6d23bf141 b/regress/corpus/634d1bea6a04431b1da127374fcce4a6d23bf141
new file mode 100644
index 0000000..17ce96f
Binary files /dev/null and b/regress/corpus/634d1bea6a04431b1da127374fcce4a6d23bf141 differ
diff --git a/regress/corpus/636fe5264807c3ddb2c87f63ae35ffbf98ea47e1 b/regress/corpus/636fe5264807c3ddb2c87f63ae35ffbf98ea47e1
new file mode 100644
index 0000000..eee6fdc
Binary files /dev/null and b/regress/corpus/636fe5264807c3ddb2c87f63ae35ffbf98ea47e1 differ
diff --git a/regress/corpus/6376602ca5d399c3140d5b5186043099d170b289 b/regress/corpus/6376602ca5d399c3140d5b5186043099d170b289
new file mode 100644
index 0000000..5d350c1
Binary files /dev/null and b/regress/corpus/6376602ca5d399c3140d5b5186043099d170b289 differ
diff --git a/regress/corpus/63a72486e93066aaa5e155a3c7b1bff0f10328a2 b/regress/corpus/63a72486e93066aaa5e155a3c7b1bff0f10328a2
new file mode 100644
index 0000000..57e538c
Binary files /dev/null and b/regress/corpus/63a72486e93066aaa5e155a3c7b1bff0f10328a2 differ
diff --git a/regress/corpus/645524aa6db78c993d1094651914fe37c83eae16 b/regress/corpus/645524aa6db78c993d1094651914fe37c83eae16
new file mode 100644
index 0000000..ec22841
Binary files /dev/null and b/regress/corpus/645524aa6db78c993d1094651914fe37c83eae16 differ
diff --git a/regress/corpus/6483a41c4dc24cf4ca16962d52632872f68585a5 b/regress/corpus/6483a41c4dc24cf4ca16962d52632872f68585a5
new file mode 100644
index 0000000..5a54546
Binary files /dev/null and b/regress/corpus/6483a41c4dc24cf4ca16962d52632872f68585a5 differ
diff --git a/regress/corpus/648a7dc78e0a604a2dbfc5587c36627ebbcb009c b/regress/corpus/648a7dc78e0a604a2dbfc5587c36627ebbcb009c
new file mode 100644
index 0000000..e3418d5
Binary files /dev/null and b/regress/corpus/648a7dc78e0a604a2dbfc5587c36627ebbcb009c differ
diff --git a/regress/corpus/64a776515121e2aa8cf2860fef262254c575998e b/regress/corpus/64a776515121e2aa8cf2860fef262254c575998e
new file mode 100644
index 0000000..4f23f38
Binary files /dev/null and b/regress/corpus/64a776515121e2aa8cf2860fef262254c575998e differ
diff --git a/regress/corpus/64df0684044c25ad10027b14a194c72c303e6dcc b/regress/corpus/64df0684044c25ad10027b14a194c72c303e6dcc
new file mode 100644
index 0000000..17c1a21
Binary files /dev/null and b/regress/corpus/64df0684044c25ad10027b14a194c72c303e6dcc differ
diff --git a/regress/corpus/64faa28a7f9e0c27e32ba48e4e19fe6153aaec41 b/regress/corpus/64faa28a7f9e0c27e32ba48e4e19fe6153aaec41
new file mode 100644
index 0000000..3283640
Binary files /dev/null and b/regress/corpus/64faa28a7f9e0c27e32ba48e4e19fe6153aaec41 differ
diff --git a/regress/corpus/6591dd2f4f7e4b2d435bd2a4d2f251a44b2809ad b/regress/corpus/6591dd2f4f7e4b2d435bd2a4d2f251a44b2809ad
new file mode 100644
index 0000000..d42aee0
Binary files /dev/null and b/regress/corpus/6591dd2f4f7e4b2d435bd2a4d2f251a44b2809ad differ
diff --git a/regress/corpus/65a58371cde36952ba98cf5dcbf4ec37564029d9 b/regress/corpus/65a58371cde36952ba98cf5dcbf4ec37564029d9
new file mode 100644
index 0000000..1c28e56
Binary files /dev/null and b/regress/corpus/65a58371cde36952ba98cf5dcbf4ec37564029d9 differ
diff --git a/regress/corpus/660a23d5bfe95cf33aeeec4a6bc5ded09aa026ba b/regress/corpus/660a23d5bfe95cf33aeeec4a6bc5ded09aa026ba
new file mode 100644
index 0000000..5d24b64
Binary files /dev/null and b/regress/corpus/660a23d5bfe95cf33aeeec4a6bc5ded09aa026ba differ
diff --git a/regress/corpus/66151af63a19ab525ee6edd595fa18ef4022eb2f b/regress/corpus/66151af63a19ab525ee6edd595fa18ef4022eb2f
new file mode 100644
index 0000000..562964e
Binary files /dev/null and b/regress/corpus/66151af63a19ab525ee6edd595fa18ef4022eb2f differ
diff --git a/regress/corpus/67570cee939ab9a5d79e5958cdba3af9d22925ed b/regress/corpus/67570cee939ab9a5d79e5958cdba3af9d22925ed
new file mode 100644
index 0000000..edd726f
Binary files /dev/null and b/regress/corpus/67570cee939ab9a5d79e5958cdba3af9d22925ed differ
diff --git a/regress/corpus/67b524146627f7c89e803c2da45b7ceca9be0bbf b/regress/corpus/67b524146627f7c89e803c2da45b7ceca9be0bbf
new file mode 100644
index 0000000..7eaaa38
Binary files /dev/null and b/regress/corpus/67b524146627f7c89e803c2da45b7ceca9be0bbf differ
diff --git a/regress/corpus/67c944e6fb20085e917523fe76e5b425b1977f72 b/regress/corpus/67c944e6fb20085e917523fe76e5b425b1977f72
new file mode 100644
index 0000000..0767cf2
Binary files /dev/null and b/regress/corpus/67c944e6fb20085e917523fe76e5b425b1977f72 differ
diff --git a/regress/corpus/67e9a4b39e9eea6a98c948d40fd403072f959b9a b/regress/corpus/67e9a4b39e9eea6a98c948d40fd403072f959b9a
new file mode 100644
index 0000000..a9b9610
Binary files /dev/null and b/regress/corpus/67e9a4b39e9eea6a98c948d40fd403072f959b9a differ
diff --git a/regress/corpus/685a009bbf4807d3d8e2a0569b073c5789d9fdaf b/regress/corpus/685a009bbf4807d3d8e2a0569b073c5789d9fdaf
new file mode 100644
index 0000000..134bd17
Binary files /dev/null and b/regress/corpus/685a009bbf4807d3d8e2a0569b073c5789d9fdaf differ
diff --git a/regress/corpus/68cc1cf39a47124f89ec1df050768c520bccfcae b/regress/corpus/68cc1cf39a47124f89ec1df050768c520bccfcae
new file mode 100644
index 0000000..b36c741
Binary files /dev/null and b/regress/corpus/68cc1cf39a47124f89ec1df050768c520bccfcae differ
diff --git a/regress/corpus/68fc29ea0632a99087f0271a3a3badbca62ca8b4 b/regress/corpus/68fc29ea0632a99087f0271a3a3badbca62ca8b4
new file mode 100644
index 0000000..27e7b64
Binary files /dev/null and b/regress/corpus/68fc29ea0632a99087f0271a3a3badbca62ca8b4 differ
diff --git a/regress/corpus/691ab3d0867cce67924089b0a6a88b4228a2ccad b/regress/corpus/691ab3d0867cce67924089b0a6a88b4228a2ccad
new file mode 100644
index 0000000..6815d9b
Binary files /dev/null and b/regress/corpus/691ab3d0867cce67924089b0a6a88b4228a2ccad differ
diff --git a/regress/corpus/695393868db0cb0e16d34a65f495af1687efc32b b/regress/corpus/695393868db0cb0e16d34a65f495af1687efc32b
new file mode 100644
index 0000000..c147de3
--- /dev/null
+++ b/regress/corpus/695393868db0cb0e16d34a65f495af1687efc32b
@@ -0,0 +1 @@
+	¹¹
\ No newline at end of file
diff --git a/regress/corpus/69f4521858a39cd1ec980ff6cd27e46bfc3dc34c b/regress/corpus/69f4521858a39cd1ec980ff6cd27e46bfc3dc34c
new file mode 100644
index 0000000..759cb31
Binary files /dev/null and b/regress/corpus/69f4521858a39cd1ec980ff6cd27e46bfc3dc34c differ
diff --git a/regress/corpus/6a5c9ebb65a8aa4cb57aeccfb19b4d892093e418 b/regress/corpus/6a5c9ebb65a8aa4cb57aeccfb19b4d892093e418
new file mode 100644
index 0000000..5321e94
Binary files /dev/null and b/regress/corpus/6a5c9ebb65a8aa4cb57aeccfb19b4d892093e418 differ
diff --git a/regress/corpus/6a91265e13e44ed64da1521358cd31f90acc3446 b/regress/corpus/6a91265e13e44ed64da1521358cd31f90acc3446
new file mode 100644
index 0000000..157c09e
Binary files /dev/null and b/regress/corpus/6a91265e13e44ed64da1521358cd31f90acc3446 differ
diff --git a/regress/corpus/6b41c9fe9640cab2ffc743edef96da1837b2e092 b/regress/corpus/6b41c9fe9640cab2ffc743edef96da1837b2e092
new file mode 100644
index 0000000..5ab76aa
Binary files /dev/null and b/regress/corpus/6b41c9fe9640cab2ffc743edef96da1837b2e092 differ
diff --git a/regress/corpus/6b4fbcfa924f1ab19d2a96f385cd5b0f35da5fb3 b/regress/corpus/6b4fbcfa924f1ab19d2a96f385cd5b0f35da5fb3
new file mode 100644
index 0000000..ff7714a
Binary files /dev/null and b/regress/corpus/6b4fbcfa924f1ab19d2a96f385cd5b0f35da5fb3 differ
diff --git a/regress/corpus/6b7025638f5bd0d685f93a39a88b91a7975f0edb b/regress/corpus/6b7025638f5bd0d685f93a39a88b91a7975f0edb
new file mode 100644
index 0000000..0368ed2
--- /dev/null
+++ b/regress/corpus/6b7025638f5bd0d685f93a39a88b91a7975f0edb
@@ -0,0 +1 @@
+sss
\ No newline at end of file
diff --git a/regress/corpus/6be55eb4caac42da1819d88b592ed312dbf9056c b/regress/corpus/6be55eb4caac42da1819d88b592ed312dbf9056c
new file mode 100644
index 0000000..39cb147
Binary files /dev/null and b/regress/corpus/6be55eb4caac42da1819d88b592ed312dbf9056c differ
diff --git a/regress/corpus/6c1e78b9df9aefd82cf0b0d172c864d6c8c8e5dc b/regress/corpus/6c1e78b9df9aefd82cf0b0d172c864d6c8c8e5dc
new file mode 100644
index 0000000..b78ff19
Binary files /dev/null and b/regress/corpus/6c1e78b9df9aefd82cf0b0d172c864d6c8c8e5dc differ
diff --git a/regress/corpus/6c2199e2fae85a69114891c2d8582281b8f11613 b/regress/corpus/6c2199e2fae85a69114891c2d8582281b8f11613
new file mode 100644
index 0000000..5ec2ea1
Binary files /dev/null and b/regress/corpus/6c2199e2fae85a69114891c2d8582281b8f11613 differ
diff --git a/regress/corpus/6c6513a3d3ebad0c6b8feb0af7e5db347ad3a70b b/regress/corpus/6c6513a3d3ebad0c6b8feb0af7e5db347ad3a70b
new file mode 100644
index 0000000..e0c793a
Binary files /dev/null and b/regress/corpus/6c6513a3d3ebad0c6b8feb0af7e5db347ad3a70b differ
diff --git a/regress/corpus/6ce32bed375c24a906934aa8faf15a4f5b24ccdb b/regress/corpus/6ce32bed375c24a906934aa8faf15a4f5b24ccdb
new file mode 100644
index 0000000..49085a0
Binary files /dev/null and b/regress/corpus/6ce32bed375c24a906934aa8faf15a4f5b24ccdb differ
diff --git a/regress/corpus/6da74a9ad332c2962d01480199e8dfa2602d8792 b/regress/corpus/6da74a9ad332c2962d01480199e8dfa2602d8792
new file mode 100644
index 0000000..b480744
--- /dev/null
+++ b/regress/corpus/6da74a9ad332c2962d01480199e8dfa2602d8792
@@ -0,0 +1 @@
+Ÿùõ@
\ No newline at end of file
diff --git a/regress/corpus/6de1f9922be246583e4d25728f325d2dcd59fa24 b/regress/corpus/6de1f9922be246583e4d25728f325d2dcd59fa24
new file mode 100644
index 0000000..48af1c6
Binary files /dev/null and b/regress/corpus/6de1f9922be246583e4d25728f325d2dcd59fa24 differ
diff --git a/regress/corpus/6e645b19228683ecd903e42c12177eeaf6b07c93 b/regress/corpus/6e645b19228683ecd903e42c12177eeaf6b07c93
new file mode 100644
index 0000000..f5a87dc
Binary files /dev/null and b/regress/corpus/6e645b19228683ecd903e42c12177eeaf6b07c93 differ
diff --git a/regress/corpus/6eb6574bba71f21a05011c03875fb70b980fe93b b/regress/corpus/6eb6574bba71f21a05011c03875fb70b980fe93b
new file mode 100644
index 0000000..95535e6
Binary files /dev/null and b/regress/corpus/6eb6574bba71f21a05011c03875fb70b980fe93b differ
diff --git a/regress/corpus/6f5b6fbff217312f8a2ceeb919594cbb5bebe534 b/regress/corpus/6f5b6fbff217312f8a2ceeb919594cbb5bebe534
new file mode 100644
index 0000000..e5dab61
Binary files /dev/null and b/regress/corpus/6f5b6fbff217312f8a2ceeb919594cbb5bebe534 differ
diff --git a/regress/corpus/6f73e91a1f85bd5de4ff88fba448023370bc4010 b/regress/corpus/6f73e91a1f85bd5de4ff88fba448023370bc4010
new file mode 100644
index 0000000..26dc3b3
Binary files /dev/null and b/regress/corpus/6f73e91a1f85bd5de4ff88fba448023370bc4010 differ
diff --git a/regress/corpus/6fec053837f010b21207e6e27089d4b0eda8aded b/regress/corpus/6fec053837f010b21207e6e27089d4b0eda8aded
new file mode 100644
index 0000000..e0ff315
Binary files /dev/null and b/regress/corpus/6fec053837f010b21207e6e27089d4b0eda8aded differ
diff --git a/regress/corpus/7039e74f2c1069e1586e196cb9e5ef1034970b22 b/regress/corpus/7039e74f2c1069e1586e196cb9e5ef1034970b22
new file mode 100644
index 0000000..4aeb3f7
Binary files /dev/null and b/regress/corpus/7039e74f2c1069e1586e196cb9e5ef1034970b22 differ
diff --git a/regress/corpus/7062e45b4963d31c6805938ecd224d1fc0f769cb b/regress/corpus/7062e45b4963d31c6805938ecd224d1fc0f769cb
new file mode 100644
index 0000000..7c2725d
Binary files /dev/null and b/regress/corpus/7062e45b4963d31c6805938ecd224d1fc0f769cb differ
diff --git a/regress/corpus/70def9577abfce238371b88c4c33b251c1486cdd b/regress/corpus/70def9577abfce238371b88c4c33b251c1486cdd
new file mode 100644
index 0000000..d3c8968
Binary files /dev/null and b/regress/corpus/70def9577abfce238371b88c4c33b251c1486cdd differ
diff --git a/regress/corpus/70f293bd26336a3826077170a8309c1e5f2e0fe2 b/regress/corpus/70f293bd26336a3826077170a8309c1e5f2e0fe2
new file mode 100644
index 0000000..642c628
Binary files /dev/null and b/regress/corpus/70f293bd26336a3826077170a8309c1e5f2e0fe2 differ
diff --git a/regress/corpus/713a3a6ef8cc3bbe4a63e95419a8ad730fb3213e b/regress/corpus/713a3a6ef8cc3bbe4a63e95419a8ad730fb3213e
new file mode 100644
index 0000000..0cdc9e7
Binary files /dev/null and b/regress/corpus/713a3a6ef8cc3bbe4a63e95419a8ad730fb3213e differ
diff --git a/regress/corpus/71a6b88397b56bc194139b4d7f275121a9a98f5a b/regress/corpus/71a6b88397b56bc194139b4d7f275121a9a98f5a
new file mode 100644
index 0000000..26c6a77
Binary files /dev/null and b/regress/corpus/71a6b88397b56bc194139b4d7f275121a9a98f5a differ
diff --git a/regress/corpus/71b40990625eb94a85610b6590daae9f2c6dc61c b/regress/corpus/71b40990625eb94a85610b6590daae9f2c6dc61c
new file mode 100644
index 0000000..63b4085
Binary files /dev/null and b/regress/corpus/71b40990625eb94a85610b6590daae9f2c6dc61c differ
diff --git a/regress/corpus/71b598ea180d896d31b86275641378fbb9f66945 b/regress/corpus/71b598ea180d896d31b86275641378fbb9f66945
new file mode 100644
index 0000000..4dff9d2
Binary files /dev/null and b/regress/corpus/71b598ea180d896d31b86275641378fbb9f66945 differ
diff --git a/regress/corpus/71b8a87696b6f8ab958c9f51d8bcddd8d97d1576 b/regress/corpus/71b8a87696b6f8ab958c9f51d8bcddd8d97d1576
new file mode 100644
index 0000000..1fd3cb4
Binary files /dev/null and b/regress/corpus/71b8a87696b6f8ab958c9f51d8bcddd8d97d1576 differ
diff --git a/regress/corpus/71b9769eda3d7ddd312f5414ed94cb7e3634e620 b/regress/corpus/71b9769eda3d7ddd312f5414ed94cb7e3634e620
new file mode 100644
index 0000000..350a9a3
Binary files /dev/null and b/regress/corpus/71b9769eda3d7ddd312f5414ed94cb7e3634e620 differ
diff --git a/regress/corpus/7229ea328368da01b3acd0778271c5bf61089336 b/regress/corpus/7229ea328368da01b3acd0778271c5bf61089336
new file mode 100644
index 0000000..bf77985
Binary files /dev/null and b/regress/corpus/7229ea328368da01b3acd0778271c5bf61089336 differ
diff --git a/regress/corpus/72446bc7bca0f2abee22c8549b91755ea58a55af b/regress/corpus/72446bc7bca0f2abee22c8549b91755ea58a55af
new file mode 100644
index 0000000..504c516
Binary files /dev/null and b/regress/corpus/72446bc7bca0f2abee22c8549b91755ea58a55af differ
diff --git a/regress/corpus/7285575fac0cbe4574cb21867b5285f86744590a b/regress/corpus/7285575fac0cbe4574cb21867b5285f86744590a
new file mode 100644
index 0000000..e37e1b0
Binary files /dev/null and b/regress/corpus/7285575fac0cbe4574cb21867b5285f86744590a differ
diff --git a/regress/corpus/72892615ed350434673b46ab87b249a741b21ca9 b/regress/corpus/72892615ed350434673b46ab87b249a741b21ca9
new file mode 100644
index 0000000..2780110
Binary files /dev/null and b/regress/corpus/72892615ed350434673b46ab87b249a741b21ca9 differ
diff --git a/regress/corpus/72a390f826f14b12b1aff4f3598c61978ba14f89 b/regress/corpus/72a390f826f14b12b1aff4f3598c61978ba14f89
new file mode 100644
index 0000000..174edb5
Binary files /dev/null and b/regress/corpus/72a390f826f14b12b1aff4f3598c61978ba14f89 differ
diff --git a/regress/corpus/732a8ea6afc31706bbf621633a7c7a3fcb7a2884 b/regress/corpus/732a8ea6afc31706bbf621633a7c7a3fcb7a2884
new file mode 100644
index 0000000..42ab908
Binary files /dev/null and b/regress/corpus/732a8ea6afc31706bbf621633a7c7a3fcb7a2884 differ
diff --git a/regress/corpus/7396c4804d631f59e4b43c7d7f5b52ce07406e1b b/regress/corpus/7396c4804d631f59e4b43c7d7f5b52ce07406e1b
new file mode 100644
index 0000000..eefacef
Binary files /dev/null and b/regress/corpus/7396c4804d631f59e4b43c7d7f5b52ce07406e1b differ
diff --git a/regress/corpus/73a2faa98ee12889bc52fb0e939abf6163b3bf8a b/regress/corpus/73a2faa98ee12889bc52fb0e939abf6163b3bf8a
new file mode 100644
index 0000000..f69e0f8
Binary files /dev/null and b/regress/corpus/73a2faa98ee12889bc52fb0e939abf6163b3bf8a differ
diff --git a/regress/corpus/73b363dfa85a94af3d185face26e2bd4525fa1e2 b/regress/corpus/73b363dfa85a94af3d185face26e2bd4525fa1e2
new file mode 100644
index 0000000..d9ce689
Binary files /dev/null and b/regress/corpus/73b363dfa85a94af3d185face26e2bd4525fa1e2 differ
diff --git a/regress/corpus/73d499daf3609303169702b78fec396636aa0d05 b/regress/corpus/73d499daf3609303169702b78fec396636aa0d05
new file mode 100644
index 0000000..332c203
Binary files /dev/null and b/regress/corpus/73d499daf3609303169702b78fec396636aa0d05 differ
diff --git a/regress/corpus/74120f8360c18539b35d75e5e27e04cceaf7c7d9 b/regress/corpus/74120f8360c18539b35d75e5e27e04cceaf7c7d9
new file mode 100644
index 0000000..6f4788d
Binary files /dev/null and b/regress/corpus/74120f8360c18539b35d75e5e27e04cceaf7c7d9 differ
diff --git a/regress/corpus/74b04a5625ccff993592e12bccae1327e5fcbfee b/regress/corpus/74b04a5625ccff993592e12bccae1327e5fcbfee
new file mode 100644
index 0000000..d31a759
Binary files /dev/null and b/regress/corpus/74b04a5625ccff993592e12bccae1327e5fcbfee differ
diff --git a/regress/corpus/74ceffd068740ddf10ff45a41494f62ebdf44403 b/regress/corpus/74ceffd068740ddf10ff45a41494f62ebdf44403
new file mode 100644
index 0000000..adb7791
Binary files /dev/null and b/regress/corpus/74ceffd068740ddf10ff45a41494f62ebdf44403 differ
diff --git a/regress/corpus/75184afc2e443e8fbaa6608d90de86984994c220 b/regress/corpus/75184afc2e443e8fbaa6608d90de86984994c220
new file mode 100644
index 0000000..e96fe35
Binary files /dev/null and b/regress/corpus/75184afc2e443e8fbaa6608d90de86984994c220 differ
diff --git a/regress/corpus/753a6431e8953e63ededb10b67b98a33209f303c b/regress/corpus/753a6431e8953e63ededb10b67b98a33209f303c
new file mode 100644
index 0000000..62123b0
Binary files /dev/null and b/regress/corpus/753a6431e8953e63ededb10b67b98a33209f303c differ
diff --git a/regress/corpus/75dafc5ef9b0a8fb83804810bd4a422829156067 b/regress/corpus/75dafc5ef9b0a8fb83804810bd4a422829156067
new file mode 100644
index 0000000..076b3c9
Binary files /dev/null and b/regress/corpus/75dafc5ef9b0a8fb83804810bd4a422829156067 differ
diff --git a/regress/corpus/768753c1deff240cadd1656424e37c39db1e63ce b/regress/corpus/768753c1deff240cadd1656424e37c39db1e63ce
new file mode 100644
index 0000000..a019c3d
Binary files /dev/null and b/regress/corpus/768753c1deff240cadd1656424e37c39db1e63ce differ
diff --git a/regress/corpus/76bde6a032b06a5ec3e2fc23422bc7efd4d882e8 b/regress/corpus/76bde6a032b06a5ec3e2fc23422bc7efd4d882e8
new file mode 100644
index 0000000..852e7a7
Binary files /dev/null and b/regress/corpus/76bde6a032b06a5ec3e2fc23422bc7efd4d882e8 differ
diff --git a/regress/corpus/76c6e2daaeb6b0d825a96277228d08c2e73b438e b/regress/corpus/76c6e2daaeb6b0d825a96277228d08c2e73b438e
new file mode 100644
index 0000000..5c6e675
Binary files /dev/null and b/regress/corpus/76c6e2daaeb6b0d825a96277228d08c2e73b438e differ
diff --git a/regress/corpus/76d81862c65f9191a35069f713e46a2228c3ea46 b/regress/corpus/76d81862c65f9191a35069f713e46a2228c3ea46
new file mode 100644
index 0000000..8934ca9
Binary files /dev/null and b/regress/corpus/76d81862c65f9191a35069f713e46a2228c3ea46 differ
diff --git a/regress/corpus/76e4b298d466e78d2ededf80f450df22b073df8b b/regress/corpus/76e4b298d466e78d2ededf80f450df22b073df8b
new file mode 100644
index 0000000..93b128f
Binary files /dev/null and b/regress/corpus/76e4b298d466e78d2ededf80f450df22b073df8b differ
diff --git a/regress/corpus/76fb713e8a6b1b74b569fdfe3cd29e31d87ec60b b/regress/corpus/76fb713e8a6b1b74b569fdfe3cd29e31d87ec60b
new file mode 100644
index 0000000..8004243
Binary files /dev/null and b/regress/corpus/76fb713e8a6b1b74b569fdfe3cd29e31d87ec60b differ
diff --git a/regress/corpus/7702e425ab1e031a64c17265e5144d3b09c430dd b/regress/corpus/7702e425ab1e031a64c17265e5144d3b09c430dd
new file mode 100644
index 0000000..479f95f
Binary files /dev/null and b/regress/corpus/7702e425ab1e031a64c17265e5144d3b09c430dd differ
diff --git a/regress/corpus/775ff2bff9d70f02afd423569d3162760dea3ce1 b/regress/corpus/775ff2bff9d70f02afd423569d3162760dea3ce1
new file mode 100644
index 0000000..943f974
Binary files /dev/null and b/regress/corpus/775ff2bff9d70f02afd423569d3162760dea3ce1 differ
diff --git a/regress/corpus/778457000cb0f413ef1af1051a0fc027b38987a7 b/regress/corpus/778457000cb0f413ef1af1051a0fc027b38987a7
new file mode 100644
index 0000000..46fa728
Binary files /dev/null and b/regress/corpus/778457000cb0f413ef1af1051a0fc027b38987a7 differ
diff --git a/regress/corpus/77c59bf3c9a0690dca13e22c100f4b8549709a87 b/regress/corpus/77c59bf3c9a0690dca13e22c100f4b8549709a87
new file mode 100644
index 0000000..f1eefdd
Binary files /dev/null and b/regress/corpus/77c59bf3c9a0690dca13e22c100f4b8549709a87 differ
diff --git a/regress/corpus/77d6f8901fadfb86bd4c8b81858cd7984af344d3 b/regress/corpus/77d6f8901fadfb86bd4c8b81858cd7984af344d3
new file mode 100644
index 0000000..98acd35
--- /dev/null
+++ b/regress/corpus/77d6f8901fadfb86bd4c8b81858cd7984af344d3
@@ -0,0 +1 @@
+




















5555555555555'51111110




\ No newline at end of file
diff --git a/regress/corpus/78069c262fb1122b671027f10bb7b435c0a40d4b b/regress/corpus/78069c262fb1122b671027f10bb7b435c0a40d4b
new file mode 100644
index 0000000..9838f3b
Binary files /dev/null and b/regress/corpus/78069c262fb1122b671027f10bb7b435c0a40d4b differ
diff --git a/regress/corpus/78666fae05ebeec6a72fab2638f0588910705270 b/regress/corpus/78666fae05ebeec6a72fab2638f0588910705270
new file mode 100644
index 0000000..0486ee2
Binary files /dev/null and b/regress/corpus/78666fae05ebeec6a72fab2638f0588910705270 differ
diff --git a/regress/corpus/788b1e9c64973e727ef08cf00e666fc8bf4bb30c b/regress/corpus/788b1e9c64973e727ef08cf00e666fc8bf4bb30c
new file mode 100644
index 0000000..2aad81f
Binary files /dev/null and b/regress/corpus/788b1e9c64973e727ef08cf00e666fc8bf4bb30c differ
diff --git a/regress/corpus/7976204757edff2deb1c156e650271359b212f9a b/regress/corpus/7976204757edff2deb1c156e650271359b212f9a
new file mode 100644
index 0000000..fc41dd1
Binary files /dev/null and b/regress/corpus/7976204757edff2deb1c156e650271359b212f9a differ
diff --git a/regress/corpus/79ab59841d2763abb325ed9d4a3666e817f6ff1d b/regress/corpus/79ab59841d2763abb325ed9d4a3666e817f6ff1d
new file mode 100644
index 0000000..3f1cbfd
Binary files /dev/null and b/regress/corpus/79ab59841d2763abb325ed9d4a3666e817f6ff1d differ
diff --git a/regress/corpus/79ce700d55c2cca2c13d508c2cd308136d0faca5 b/regress/corpus/79ce700d55c2cca2c13d508c2cd308136d0faca5
new file mode 100644
index 0000000..bfb5da2
Binary files /dev/null and b/regress/corpus/79ce700d55c2cca2c13d508c2cd308136d0faca5 differ
diff --git a/regress/corpus/7a07f1115943cbeb261599359693693806587249 b/regress/corpus/7a07f1115943cbeb261599359693693806587249
new file mode 100644
index 0000000..9296585
--- /dev/null
+++ b/regress/corpus/7a07f1115943cbeb261599359693693806587249
@@ -0,0 +1 @@
+.@
\ No newline at end of file
diff --git a/regress/corpus/7a4f386a916b438769395c6716428815883ccc47 b/regress/corpus/7a4f386a916b438769395c6716428815883ccc47
new file mode 100644
index 0000000..4960584
Binary files /dev/null and b/regress/corpus/7a4f386a916b438769395c6716428815883ccc47 differ
diff --git a/regress/corpus/7ad32f0267ee22966343bcec49f2a793afea9a0a b/regress/corpus/7ad32f0267ee22966343bcec49f2a793afea9a0a
new file mode 100644
index 0000000..7cb7f7a
Binary files /dev/null and b/regress/corpus/7ad32f0267ee22966343bcec49f2a793afea9a0a differ
diff --git a/regress/corpus/7b2d569c5e59254eb74304b66650be0fbec34507 b/regress/corpus/7b2d569c5e59254eb74304b66650be0fbec34507
new file mode 100644
index 0000000..9d29657
Binary files /dev/null and b/regress/corpus/7b2d569c5e59254eb74304b66650be0fbec34507 differ
diff --git a/regress/corpus/7c8f95736613be82e6ffd65eeda1755bb5978944 b/regress/corpus/7c8f95736613be82e6ffd65eeda1755bb5978944
new file mode 100644
index 0000000..34d9705
Binary files /dev/null and b/regress/corpus/7c8f95736613be82e6ffd65eeda1755bb5978944 differ
diff --git a/regress/corpus/7d23baf78bd1aabc420728b302eeeaa7342d603f b/regress/corpus/7d23baf78bd1aabc420728b302eeeaa7342d603f
new file mode 100644
index 0000000..d2560f4
Binary files /dev/null and b/regress/corpus/7d23baf78bd1aabc420728b302eeeaa7342d603f differ
diff --git a/regress/corpus/7d65993eacfcdd2df30430de41ac34aeacb0bfe0 b/regress/corpus/7d65993eacfcdd2df30430de41ac34aeacb0bfe0
new file mode 100644
index 0000000..570e330
Binary files /dev/null and b/regress/corpus/7d65993eacfcdd2df30430de41ac34aeacb0bfe0 differ
diff --git a/regress/corpus/7d929dd1ea098b5968c1378b62c52251012040d7 b/regress/corpus/7d929dd1ea098b5968c1378b62c52251012040d7
new file mode 100644
index 0000000..9416333
Binary files /dev/null and b/regress/corpus/7d929dd1ea098b5968c1378b62c52251012040d7 differ
diff --git a/regress/corpus/7d9473f69165c134441599b7105011d7a74164b9 b/regress/corpus/7d9473f69165c134441599b7105011d7a74164b9
new file mode 100644
index 0000000..0acf748
--- /dev/null
+++ b/regress/corpus/7d9473f69165c134441599b7105011d7a74164b9
@@ -0,0 +1 @@
+








































99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999















































 Ž 
ÿ 

\ No newline at end of file
diff --git a/regress/corpus/7dd3e4f69afcaf3457a7eb5bb8ccb5cfd1409c08 b/regress/corpus/7dd3e4f69afcaf3457a7eb5bb8ccb5cfd1409c08
new file mode 100644
index 0000000..934e8ee
Binary files /dev/null and b/regress/corpus/7dd3e4f69afcaf3457a7eb5bb8ccb5cfd1409c08 differ
diff --git a/regress/corpus/7de2c673758bf2a01287d3e6baecfc89ce548416 b/regress/corpus/7de2c673758bf2a01287d3e6baecfc89ce548416
new file mode 100644
index 0000000..a92c3b0
Binary files /dev/null and b/regress/corpus/7de2c673758bf2a01287d3e6baecfc89ce548416 differ
diff --git a/regress/corpus/7e115dc681dbce159584ef166c3a53758fb15808 b/regress/corpus/7e115dc681dbce159584ef166c3a53758fb15808
new file mode 100644
index 0000000..1380b08
Binary files /dev/null and b/regress/corpus/7e115dc681dbce159584ef166c3a53758fb15808 differ
diff --git a/regress/corpus/7e1c71a370e88fde0cb3ab65f5088943e2f23ac5 b/regress/corpus/7e1c71a370e88fde0cb3ab65f5088943e2f23ac5
new file mode 100644
index 0000000..aad4331
Binary files /dev/null and b/regress/corpus/7e1c71a370e88fde0cb3ab65f5088943e2f23ac5 differ
diff --git a/regress/corpus/7e1d75233e2ae49cb21aa2f844accba92d3d0c63 b/regress/corpus/7e1d75233e2ae49cb21aa2f844accba92d3d0c63
new file mode 100644
index 0000000..f6a3dbf
Binary files /dev/null and b/regress/corpus/7e1d75233e2ae49cb21aa2f844accba92d3d0c63 differ
diff --git a/regress/corpus/7e3c77aa0e75eac9dcb2094f806d80308f1dfb14 b/regress/corpus/7e3c77aa0e75eac9dcb2094f806d80308f1dfb14
new file mode 100644
index 0000000..8ed0d1d
--- /dev/null
+++ b/regress/corpus/7e3c77aa0e75eac9dcb2094f806d80308f1dfb14
@@ -0,0 +1 @@
+
¹
\ No newline at end of file
diff --git a/regress/corpus/7e8a3b6cb88417495876ada5fd0302c24648e987 b/regress/corpus/7e8a3b6cb88417495876ada5fd0302c24648e987
new file mode 100644
index 0000000..8be4a56
Binary files /dev/null and b/regress/corpus/7e8a3b6cb88417495876ada5fd0302c24648e987 differ
diff --git a/regress/corpus/7e9fbd02bb6d60ccbb48d9488ec16a2a752b670c b/regress/corpus/7e9fbd02bb6d60ccbb48d9488ec16a2a752b670c
new file mode 100644
index 0000000..cfe40bb
Binary files /dev/null and b/regress/corpus/7e9fbd02bb6d60ccbb48d9488ec16a2a752b670c differ
diff --git a/regress/corpus/7f40ed4ababf3c3f5ea4430db085173f21a031e1 b/regress/corpus/7f40ed4ababf3c3f5ea4430db085173f21a031e1
new file mode 100644
index 0000000..1924412
Binary files /dev/null and b/regress/corpus/7f40ed4ababf3c3f5ea4430db085173f21a031e1 differ
diff --git a/regress/corpus/7f69d413efa83f0dbde3888ec5e4a3221416ce66 b/regress/corpus/7f69d413efa83f0dbde3888ec5e4a3221416ce66
new file mode 100644
index 0000000..c616ba2
Binary files /dev/null and b/regress/corpus/7f69d413efa83f0dbde3888ec5e4a3221416ce66 differ
diff --git a/regress/corpus/7fb538cf9b714f920777b9eacdc743e63d027788 b/regress/corpus/7fb538cf9b714f920777b9eacdc743e63d027788
new file mode 100644
index 0000000..7023df4
--- /dev/null
+++ b/regress/corpus/7fb538cf9b714f920777b9eacdc743e63d027788
@@ -0,0 +1 @@
+^ÿ@
\ No newline at end of file
diff --git a/regress/corpus/7fc48b4dcabf565bd1cdd5a27897d9bb066b7471 b/regress/corpus/7fc48b4dcabf565bd1cdd5a27897d9bb066b7471
new file mode 100644
index 0000000..3894377
Binary files /dev/null and b/regress/corpus/7fc48b4dcabf565bd1cdd5a27897d9bb066b7471 differ
diff --git a/regress/corpus/7fdc5e2599199fda28e2f5445a05ad95ddc0cd90 b/regress/corpus/7fdc5e2599199fda28e2f5445a05ad95ddc0cd90
new file mode 100644
index 0000000..20f42e2
Binary files /dev/null and b/regress/corpus/7fdc5e2599199fda28e2f5445a05ad95ddc0cd90 differ
diff --git a/regress/corpus/803450bd45401a97b6e4ba3021a8aa1d155b5265 b/regress/corpus/803450bd45401a97b6e4ba3021a8aa1d155b5265
new file mode 100644
index 0000000..1b0a83f
Binary files /dev/null and b/regress/corpus/803450bd45401a97b6e4ba3021a8aa1d155b5265 differ
diff --git a/regress/corpus/807bc2baabe4fdc5212a584ff08c0c28bbdba567 b/regress/corpus/807bc2baabe4fdc5212a584ff08c0c28bbdba567
new file mode 100644
index 0000000..ced1a5c
Binary files /dev/null and b/regress/corpus/807bc2baabe4fdc5212a584ff08c0c28bbdba567 differ
diff --git a/regress/corpus/815347f5bfa8b529db1c89f5e2a66b7cc3ab2bfc b/regress/corpus/815347f5bfa8b529db1c89f5e2a66b7cc3ab2bfc
new file mode 100644
index 0000000..96a631a
Binary files /dev/null and b/regress/corpus/815347f5bfa8b529db1c89f5e2a66b7cc3ab2bfc differ
diff --git a/regress/corpus/821718b25668aabe57d82d73a3a83543290ea20b b/regress/corpus/821718b25668aabe57d82d73a3a83543290ea20b
new file mode 100644
index 0000000..f4f682a
Binary files /dev/null and b/regress/corpus/821718b25668aabe57d82d73a3a83543290ea20b differ
diff --git a/regress/corpus/822e21892f128ed512c425dbbf9d359227edc62e b/regress/corpus/822e21892f128ed512c425dbbf9d359227edc62e
new file mode 100644
index 0000000..cb1d0ea
Binary files /dev/null and b/regress/corpus/822e21892f128ed512c425dbbf9d359227edc62e differ
diff --git a/regress/corpus/826a05ecc37a32952a4c06e4bc16465e36836e1a b/regress/corpus/826a05ecc37a32952a4c06e4bc16465e36836e1a
new file mode 100644
index 0000000..a941006
Binary files /dev/null and b/regress/corpus/826a05ecc37a32952a4c06e4bc16465e36836e1a differ
diff --git a/regress/corpus/8279543331b091f3c7a6c49fe1ddca4a1a0cec36 b/regress/corpus/8279543331b091f3c7a6c49fe1ddca4a1a0cec36
new file mode 100644
index 0000000..f8d9d2c
Binary files /dev/null and b/regress/corpus/8279543331b091f3c7a6c49fe1ddca4a1a0cec36 differ
diff --git a/regress/corpus/82ae89b113bf455728ded19880282984f86d6ee9 b/regress/corpus/82ae89b113bf455728ded19880282984f86d6ee9
new file mode 100644
index 0000000..ccd69a2
--- /dev/null
+++ b/regress/corpus/82ae89b113bf455728ded19880282984f86d6ee9
@@ -0,0 +1 @@
+ Ž 
ÿ 

\ No newline at end of file
diff --git a/regress/corpus/82f8098af20a1a22f8439d8ba51425168378b710 b/regress/corpus/82f8098af20a1a22f8439d8ba51425168378b710
new file mode 100644
index 0000000..c64c65d
Binary files /dev/null and b/regress/corpus/82f8098af20a1a22f8439d8ba51425168378b710 differ
diff --git a/regress/corpus/8301f70b5769d751da2be0c445d3b3b5078c5b31 b/regress/corpus/8301f70b5769d751da2be0c445d3b3b5078c5b31
new file mode 100644
index 0000000..8bc8fd8
Binary files /dev/null and b/regress/corpus/8301f70b5769d751da2be0c445d3b3b5078c5b31 differ
diff --git a/regress/corpus/8379b56f6ba2269e4225ba0ae160e18b7bc0cb1d b/regress/corpus/8379b56f6ba2269e4225ba0ae160e18b7bc0cb1d
new file mode 100644
index 0000000..8390a25
Binary files /dev/null and b/regress/corpus/8379b56f6ba2269e4225ba0ae160e18b7bc0cb1d differ
diff --git a/regress/corpus/838d7952e2fcb725c9ff91063784a309e8a29663 b/regress/corpus/838d7952e2fcb725c9ff91063784a309e8a29663
new file mode 100644
index 0000000..9591762
Binary files /dev/null and b/regress/corpus/838d7952e2fcb725c9ff91063784a309e8a29663 differ
diff --git a/regress/corpus/83e3c53e8a4510be7fedba14aa21366dc737b8e2 b/regress/corpus/83e3c53e8a4510be7fedba14aa21366dc737b8e2
new file mode 100644
index 0000000..b740b31
Binary files /dev/null and b/regress/corpus/83e3c53e8a4510be7fedba14aa21366dc737b8e2 differ
diff --git a/regress/corpus/8464c974931e2d8066be5de680ce38d1f10fce66 b/regress/corpus/8464c974931e2d8066be5de680ce38d1f10fce66
new file mode 100644
index 0000000..b768333
Binary files /dev/null and b/regress/corpus/8464c974931e2d8066be5de680ce38d1f10fce66 differ
diff --git a/regress/corpus/84fa636ffaa8ed667982979a09129c6dd6821121 b/regress/corpus/84fa636ffaa8ed667982979a09129c6dd6821121
new file mode 100644
index 0000000..648e922
Binary files /dev/null and b/regress/corpus/84fa636ffaa8ed667982979a09129c6dd6821121 differ
diff --git a/regress/corpus/85a052e22baa83cb7191d6ea2f7ded9838a7a5ec b/regress/corpus/85a052e22baa83cb7191d6ea2f7ded9838a7a5ec
new file mode 100644
index 0000000..704f882
Binary files /dev/null and b/regress/corpus/85a052e22baa83cb7191d6ea2f7ded9838a7a5ec differ
diff --git a/regress/corpus/85ca706906ef0ba28ee0afdd9b413dbfea2bbb59 b/regress/corpus/85ca706906ef0ba28ee0afdd9b413dbfea2bbb59
new file mode 100644
index 0000000..574650c
Binary files /dev/null and b/regress/corpus/85ca706906ef0ba28ee0afdd9b413dbfea2bbb59 differ
diff --git a/regress/corpus/85eac0d93f498c1f1e16499823a369ab8594db63 b/regress/corpus/85eac0d93f498c1f1e16499823a369ab8594db63
new file mode 100644
index 0000000..25257d6
Binary files /dev/null and b/regress/corpus/85eac0d93f498c1f1e16499823a369ab8594db63 differ
diff --git a/regress/corpus/85f38964f20f6dfdaf26feabf93b0f8ecf2bae1f b/regress/corpus/85f38964f20f6dfdaf26feabf93b0f8ecf2bae1f
new file mode 100644
index 0000000..464c263
--- /dev/null
+++ b/regress/corpus/85f38964f20f6dfdaf26feabf93b0f8ecf2bae1f
@@ -0,0 +1 @@
+/?€€€€
\ No newline at end of file
diff --git a/regress/corpus/866e22b8379bb87983c163540ee980806705dec2 b/regress/corpus/866e22b8379bb87983c163540ee980806705dec2
new file mode 100644
index 0000000..8bf040b
Binary files /dev/null and b/regress/corpus/866e22b8379bb87983c163540ee980806705dec2 differ
diff --git a/regress/corpus/867687721b1ef247b457d93ab7be31af4f869bdb b/regress/corpus/867687721b1ef247b457d93ab7be31af4f869bdb
new file mode 100644
index 0000000..eab7320
Binary files /dev/null and b/regress/corpus/867687721b1ef247b457d93ab7be31af4f869bdb differ
diff --git a/regress/corpus/87149a4f5059e447efff1ecd8fab12c0caccb91d b/regress/corpus/87149a4f5059e447efff1ecd8fab12c0caccb91d
new file mode 100644
index 0000000..a253cd4
Binary files /dev/null and b/regress/corpus/87149a4f5059e447efff1ecd8fab12c0caccb91d differ
diff --git a/regress/corpus/879f89c5e3b5e218a1e48a8d18163443af5046b5 b/regress/corpus/879f89c5e3b5e218a1e48a8d18163443af5046b5
new file mode 100644
index 0000000..50fff6c
Binary files /dev/null and b/regress/corpus/879f89c5e3b5e218a1e48a8d18163443af5046b5 differ
diff --git a/regress/corpus/87edd7c4c42ae5d10a80eec3f9c2dfa2c2d7b5e7 b/regress/corpus/87edd7c4c42ae5d10a80eec3f9c2dfa2c2d7b5e7
new file mode 100644
index 0000000..226521a
Binary files /dev/null and b/regress/corpus/87edd7c4c42ae5d10a80eec3f9c2dfa2c2d7b5e7 differ
diff --git a/regress/corpus/896592235a4aa39f4c47b1d81bc1a2b465e7e673 b/regress/corpus/896592235a4aa39f4c47b1d81bc1a2b465e7e673
new file mode 100644
index 0000000..6227d08
Binary files /dev/null and b/regress/corpus/896592235a4aa39f4c47b1d81bc1a2b465e7e673 differ
diff --git a/regress/corpus/89e8712ec308913e3f74074be570eb6773401695 b/regress/corpus/89e8712ec308913e3f74074be570eb6773401695
new file mode 100644
index 0000000..67f6c78
--- /dev/null
+++ b/regress/corpus/89e8712ec308913e3f74074be570eb6773401695
@@ -0,0 +1 @@
+




















555555555555555555555555




\ No newline at end of file
diff --git a/regress/corpus/8ad09aa0227eaba348ecf5472012584552712f40 b/regress/corpus/8ad09aa0227eaba348ecf5472012584552712f40
new file mode 100644
index 0000000..59766a4
Binary files /dev/null and b/regress/corpus/8ad09aa0227eaba348ecf5472012584552712f40 differ
diff --git a/regress/corpus/8b011784120d3fd10bfb308121f26850e0b8b634 b/regress/corpus/8b011784120d3fd10bfb308121f26850e0b8b634
new file mode 100644
index 0000000..30fa937
Binary files /dev/null and b/regress/corpus/8b011784120d3fd10bfb308121f26850e0b8b634 differ
diff --git a/regress/corpus/8b4e330b4ee85f2982609be6a6fd1283b58de719 b/regress/corpus/8b4e330b4ee85f2982609be6a6fd1283b58de719
new file mode 100644
index 0000000..6bc4d4a
Binary files /dev/null and b/regress/corpus/8b4e330b4ee85f2982609be6a6fd1283b58de719 differ
diff --git a/regress/corpus/8b894bfec1e203e79539da1ecc370199af0f9e5a b/regress/corpus/8b894bfec1e203e79539da1ecc370199af0f9e5a
new file mode 100644
index 0000000..a542652
Binary files /dev/null and b/regress/corpus/8b894bfec1e203e79539da1ecc370199af0f9e5a differ
diff --git a/regress/corpus/8b8cfd770fa56164659c368b7369446aedbe1805 b/regress/corpus/8b8cfd770fa56164659c368b7369446aedbe1805
new file mode 100644
index 0000000..b1eb489
Binary files /dev/null and b/regress/corpus/8b8cfd770fa56164659c368b7369446aedbe1805 differ
diff --git a/regress/corpus/8b94bb727f993ad17f5ed86935e72272d10b1420 b/regress/corpus/8b94bb727f993ad17f5ed86935e72272d10b1420
new file mode 100644
index 0000000..d102fde
Binary files /dev/null and b/regress/corpus/8b94bb727f993ad17f5ed86935e72272d10b1420 differ
diff --git a/regress/corpus/8b96e28fabde440d384485d73e682e7c5478af62 b/regress/corpus/8b96e28fabde440d384485d73e682e7c5478af62
new file mode 100644
index 0000000..e148604
Binary files /dev/null and b/regress/corpus/8b96e28fabde440d384485d73e682e7c5478af62 differ
diff --git a/regress/corpus/8bbac41d66a921fa92f91dacaddabb240d84e622 b/regress/corpus/8bbac41d66a921fa92f91dacaddabb240d84e622
new file mode 100644
index 0000000..221da46
--- /dev/null
+++ b/regress/corpus/8bbac41d66a921fa92f91dacaddabb240d84e622
@@ -0,0 +1 @@
+	¹1?
\ No newline at end of file
diff --git a/regress/corpus/8c90057c307d293981d81b8a2e5a282b83b99df9 b/regress/corpus/8c90057c307d293981d81b8a2e5a282b83b99df9
new file mode 100644
index 0000000..57b53af
Binary files /dev/null and b/regress/corpus/8c90057c307d293981d81b8a2e5a282b83b99df9 differ
diff --git a/regress/corpus/8cd6ee7a9292ef8e83fdbf3469f79617561e68d7 b/regress/corpus/8cd6ee7a9292ef8e83fdbf3469f79617561e68d7
new file mode 100644
index 0000000..b71a6f2
Binary files /dev/null and b/regress/corpus/8cd6ee7a9292ef8e83fdbf3469f79617561e68d7 differ
diff --git a/regress/corpus/8cf71bec44cfa1c3d6f923aece9b11aa8edaa19b b/regress/corpus/8cf71bec44cfa1c3d6f923aece9b11aa8edaa19b
new file mode 100644
index 0000000..053d34d
Binary files /dev/null and b/regress/corpus/8cf71bec44cfa1c3d6f923aece9b11aa8edaa19b differ
diff --git a/regress/corpus/8d52e742b34b58da655f595e20de01a78909399a b/regress/corpus/8d52e742b34b58da655f595e20de01a78909399a
new file mode 100644
index 0000000..02b0ce3
Binary files /dev/null and b/regress/corpus/8d52e742b34b58da655f595e20de01a78909399a differ
diff --git a/regress/corpus/8d95224900ed09382d46a6a87c0812936cdd9ba4 b/regress/corpus/8d95224900ed09382d46a6a87c0812936cdd9ba4
new file mode 100644
index 0000000..1f0479b
Binary files /dev/null and b/regress/corpus/8d95224900ed09382d46a6a87c0812936cdd9ba4 differ
diff --git a/regress/corpus/8de39d7edebebc310bbdcdbb786669eabe737df6 b/regress/corpus/8de39d7edebebc310bbdcdbb786669eabe737df6
new file mode 100644
index 0000000..0dc3e8e
Binary files /dev/null and b/regress/corpus/8de39d7edebebc310bbdcdbb786669eabe737df6 differ
diff --git a/regress/corpus/8e11f353e0645d6b8c73774d787cd620eb3aff33 b/regress/corpus/8e11f353e0645d6b8c73774d787cd620eb3aff33
new file mode 100644
index 0000000..780f0e9
Binary files /dev/null and b/regress/corpus/8e11f353e0645d6b8c73774d787cd620eb3aff33 differ
diff --git a/regress/corpus/8e16aaa29d34d38ba3fb24b935d07fed1a14a967 b/regress/corpus/8e16aaa29d34d38ba3fb24b935d07fed1a14a967
new file mode 100644
index 0000000..194f9fe
Binary files /dev/null and b/regress/corpus/8e16aaa29d34d38ba3fb24b935d07fed1a14a967 differ
diff --git a/regress/corpus/8e45c124285cc897ede7f0bad0a4d4a11b823f07 b/regress/corpus/8e45c124285cc897ede7f0bad0a4d4a11b823f07
new file mode 100644
index 0000000..4258813
Binary files /dev/null and b/regress/corpus/8e45c124285cc897ede7f0bad0a4d4a11b823f07 differ
diff --git a/regress/corpus/8e45ca908c08d676a0460a93627269f3f50fd377 b/regress/corpus/8e45ca908c08d676a0460a93627269f3f50fd377
new file mode 100644
index 0000000..e16b818
Binary files /dev/null and b/regress/corpus/8e45ca908c08d676a0460a93627269f3f50fd377 differ
diff --git a/regress/corpus/8e5f0dc31df0670c8e17ee9addfe24b529514f5d b/regress/corpus/8e5f0dc31df0670c8e17ee9addfe24b529514f5d
new file mode 100644
index 0000000..983c71b
--- /dev/null
+++ b/regress/corpus/8e5f0dc31df0670c8e17ee9addfe24b529514f5d
@@ -0,0 +1 @@
+Jž
\ No newline at end of file
diff --git a/regress/corpus/8e603810478e62fd275fcd67260ba2861a6c43d7 b/regress/corpus/8e603810478e62fd275fcd67260ba2861a6c43d7
new file mode 100644
index 0000000..6d9a1dd
Binary files /dev/null and b/regress/corpus/8e603810478e62fd275fcd67260ba2861a6c43d7 differ
diff --git a/regress/corpus/8e705807465b4b22c48414d0010c56b4aa1cc1ad b/regress/corpus/8e705807465b4b22c48414d0010c56b4aa1cc1ad
new file mode 100644
index 0000000..ca8f7cf
Binary files /dev/null and b/regress/corpus/8e705807465b4b22c48414d0010c56b4aa1cc1ad differ
diff --git a/regress/corpus/8ea3eb791728e8ef9c42adbb4a7f1e9dfeeb4abc b/regress/corpus/8ea3eb791728e8ef9c42adbb4a7f1e9dfeeb4abc
new file mode 100644
index 0000000..02b9a7c
Binary files /dev/null and b/regress/corpus/8ea3eb791728e8ef9c42adbb4a7f1e9dfeeb4abc differ
diff --git a/regress/corpus/8ea46df3cd9fc812cd712434d2d8046b870555eb b/regress/corpus/8ea46df3cd9fc812cd712434d2d8046b870555eb
new file mode 100644
index 0000000..bbb5eef
Binary files /dev/null and b/regress/corpus/8ea46df3cd9fc812cd712434d2d8046b870555eb differ
diff --git a/regress/corpus/8f19dd249d8e320a3f715fa6188c2c2a047bbc97 b/regress/corpus/8f19dd249d8e320a3f715fa6188c2c2a047bbc97
new file mode 100644
index 0000000..c48f136
Binary files /dev/null and b/regress/corpus/8f19dd249d8e320a3f715fa6188c2c2a047bbc97 differ
diff --git a/regress/corpus/8f2af75e0bcfc5e78b52a04f368d3cbba10b4429 b/regress/corpus/8f2af75e0bcfc5e78b52a04f368d3cbba10b4429
new file mode 100644
index 0000000..3b60fd9
Binary files /dev/null and b/regress/corpus/8f2af75e0bcfc5e78b52a04f368d3cbba10b4429 differ
diff --git a/regress/corpus/8f88c5fa95cc7a3f0ad61588eac5f8cf46f442dc b/regress/corpus/8f88c5fa95cc7a3f0ad61588eac5f8cf46f442dc
new file mode 100644
index 0000000..e7aeddf
Binary files /dev/null and b/regress/corpus/8f88c5fa95cc7a3f0ad61588eac5f8cf46f442dc differ
diff --git a/regress/corpus/8f9c0c9fd37e8031ca00b306c7dfcde45a996f1d b/regress/corpus/8f9c0c9fd37e8031ca00b306c7dfcde45a996f1d
new file mode 100644
index 0000000..88432a0
--- /dev/null
+++ b/regress/corpus/8f9c0c9fd37e8031ca00b306c7dfcde45a996f1d
@@ -0,0 +1 @@
+„b
ÿÿÿÿÿ¹ÿÿÿÿÿ¹ÿÿ-ÿ
\ No newline at end of file
diff --git a/regress/corpus/8f9ee55232574504b81665960d13ee39a1487353 b/regress/corpus/8f9ee55232574504b81665960d13ee39a1487353
new file mode 100644
index 0000000..6abd588
Binary files /dev/null and b/regress/corpus/8f9ee55232574504b81665960d13ee39a1487353 differ
diff --git a/regress/corpus/902d8066536a59912eb8b90ac8c3965cb8564a8a b/regress/corpus/902d8066536a59912eb8b90ac8c3965cb8564a8a
new file mode 100644
index 0000000..67c915a
Binary files /dev/null and b/regress/corpus/902d8066536a59912eb8b90ac8c3965cb8564a8a differ
diff --git a/regress/corpus/9069ca78e7450a285173431b3e52c5c25299e473 b/regress/corpus/9069ca78e7450a285173431b3e52c5c25299e473
new file mode 100644
index 0000000..593f470
Binary files /dev/null and b/regress/corpus/9069ca78e7450a285173431b3e52c5c25299e473 differ
diff --git a/regress/corpus/90fdcbf7a022cb6795299ec2d0a981402e9a1999 b/regress/corpus/90fdcbf7a022cb6795299ec2d0a981402e9a1999
new file mode 100644
index 0000000..5a6795a
Binary files /dev/null and b/regress/corpus/90fdcbf7a022cb6795299ec2d0a981402e9a1999 differ
diff --git a/regress/corpus/9120d853d7b24145ece5f2ea0bebf8acd74d1f17 b/regress/corpus/9120d853d7b24145ece5f2ea0bebf8acd74d1f17
new file mode 100644
index 0000000..a2ef4c8
Binary files /dev/null and b/regress/corpus/9120d853d7b24145ece5f2ea0bebf8acd74d1f17 differ
diff --git a/regress/corpus/915521aac674e3132ed59636dbefe2a8a614219e b/regress/corpus/915521aac674e3132ed59636dbefe2a8a614219e
new file mode 100644
index 0000000..f75a20b
Binary files /dev/null and b/regress/corpus/915521aac674e3132ed59636dbefe2a8a614219e differ
diff --git a/regress/corpus/91573885d73a49dcce985de71bfe2bac92fddf28 b/regress/corpus/91573885d73a49dcce985de71bfe2bac92fddf28
new file mode 100644
index 0000000..edd4d47
Binary files /dev/null and b/regress/corpus/91573885d73a49dcce985de71bfe2bac92fddf28 differ
diff --git a/regress/corpus/9167b740c4d2f8a0d279d2286bc039a92d2485c8 b/regress/corpus/9167b740c4d2f8a0d279d2286bc039a92d2485c8
new file mode 100644
index 0000000..670edfe
Binary files /dev/null and b/regress/corpus/9167b740c4d2f8a0d279d2286bc039a92d2485c8 differ
diff --git a/regress/corpus/9167c2ee7884cca512a25c5c46047a51a8ee0037 b/regress/corpus/9167c2ee7884cca512a25c5c46047a51a8ee0037
new file mode 100644
index 0000000..cb12294
Binary files /dev/null and b/regress/corpus/9167c2ee7884cca512a25c5c46047a51a8ee0037 differ
diff --git a/regress/corpus/91ea1b5bb00a93330eefd83d06dc30070a8a4a77 b/regress/corpus/91ea1b5bb00a93330eefd83d06dc30070a8a4a77
new file mode 100644
index 0000000..aa38960
Binary files /dev/null and b/regress/corpus/91ea1b5bb00a93330eefd83d06dc30070a8a4a77 differ
diff --git a/regress/corpus/922c7c3f7b2ce7e996fa24e0e259e71033a0bc79 b/regress/corpus/922c7c3f7b2ce7e996fa24e0e259e71033a0bc79
new file mode 100644
index 0000000..9eaa962
Binary files /dev/null and b/regress/corpus/922c7c3f7b2ce7e996fa24e0e259e71033a0bc79 differ
diff --git a/regress/corpus/924dca3b94a8a9ed3029f9bea1de5bab3ffc0624 b/regress/corpus/924dca3b94a8a9ed3029f9bea1de5bab3ffc0624
new file mode 100644
index 0000000..8181084
Binary files /dev/null and b/regress/corpus/924dca3b94a8a9ed3029f9bea1de5bab3ffc0624 differ
diff --git a/regress/corpus/92a4fc3e3882d623e160b449b8c5d00b6cf5541a b/regress/corpus/92a4fc3e3882d623e160b449b8c5d00b6cf5541a
new file mode 100644
index 0000000..cdfab62
Binary files /dev/null and b/regress/corpus/92a4fc3e3882d623e160b449b8c5d00b6cf5541a differ
diff --git a/regress/corpus/92d5f1fd799ea3387dfbcf34e9454eb39022e891 b/regress/corpus/92d5f1fd799ea3387dfbcf34e9454eb39022e891
new file mode 100644
index 0000000..e1e47ba
Binary files /dev/null and b/regress/corpus/92d5f1fd799ea3387dfbcf34e9454eb39022e891 differ
diff --git a/regress/corpus/9307e86e985db1fea0f0939d211712d2ee5277c4 b/regress/corpus/9307e86e985db1fea0f0939d211712d2ee5277c4
new file mode 100644
index 0000000..64b167e
Binary files /dev/null and b/regress/corpus/9307e86e985db1fea0f0939d211712d2ee5277c4 differ
diff --git a/regress/corpus/931358fa84efac651ec27d64805438e0e80841a0 b/regress/corpus/931358fa84efac651ec27d64805438e0e80841a0
new file mode 100644
index 0000000..3097562
Binary files /dev/null and b/regress/corpus/931358fa84efac651ec27d64805438e0e80841a0 differ
diff --git a/regress/corpus/932c040949d2188ae41e16e391010331fa9d7c10 b/regress/corpus/932c040949d2188ae41e16e391010331fa9d7c10
new file mode 100644
index 0000000..0423d78
Binary files /dev/null and b/regress/corpus/932c040949d2188ae41e16e391010331fa9d7c10 differ
diff --git a/regress/corpus/937661a0e2419e7068f3d52098a3fbabee12bbff b/regress/corpus/937661a0e2419e7068f3d52098a3fbabee12bbff
new file mode 100644
index 0000000..b38e250
Binary files /dev/null and b/regress/corpus/937661a0e2419e7068f3d52098a3fbabee12bbff differ
diff --git a/regress/corpus/93b1dd76197a98c1dd003731cb19f826905c99c6 b/regress/corpus/93b1dd76197a98c1dd003731cb19f826905c99c6
new file mode 100644
index 0000000..3a3d74e
Binary files /dev/null and b/regress/corpus/93b1dd76197a98c1dd003731cb19f826905c99c6 differ
diff --git a/regress/corpus/93ce6463d6320c7f6c25d69d05013afdae31210b b/regress/corpus/93ce6463d6320c7f6c25d69d05013afdae31210b
new file mode 100644
index 0000000..5e6ab44
Binary files /dev/null and b/regress/corpus/93ce6463d6320c7f6c25d69d05013afdae31210b differ
diff --git a/regress/corpus/93e87708ae49d4ecce34d19fb158170823c65a25 b/regress/corpus/93e87708ae49d4ecce34d19fb158170823c65a25
new file mode 100644
index 0000000..57408bd
Binary files /dev/null and b/regress/corpus/93e87708ae49d4ecce34d19fb158170823c65a25 differ
diff --git a/regress/corpus/942c6c3d6165595504b4f6288812ea11bac43bab b/regress/corpus/942c6c3d6165595504b4f6288812ea11bac43bab
new file mode 100644
index 0000000..88242bd
Binary files /dev/null and b/regress/corpus/942c6c3d6165595504b4f6288812ea11bac43bab differ
diff --git a/regress/corpus/944771f50947af2b24dfa61029b4d27a93939dea b/regress/corpus/944771f50947af2b24dfa61029b4d27a93939dea
new file mode 100644
index 0000000..4b175b4
Binary files /dev/null and b/regress/corpus/944771f50947af2b24dfa61029b4d27a93939dea differ
diff --git a/regress/corpus/94b58973cc02b03f39e841b6d46d18a747140d0f b/regress/corpus/94b58973cc02b03f39e841b6d46d18a747140d0f
new file mode 100644
index 0000000..9fe9881
Binary files /dev/null and b/regress/corpus/94b58973cc02b03f39e841b6d46d18a747140d0f differ
diff --git a/regress/corpus/94efa6407e5aab15c2a342ba3fcad52295fb9814 b/regress/corpus/94efa6407e5aab15c2a342ba3fcad52295fb9814
new file mode 100644
index 0000000..d662047
Binary files /dev/null and b/regress/corpus/94efa6407e5aab15c2a342ba3fcad52295fb9814 differ
diff --git a/regress/corpus/954eabc7f4915e55ab72abaae18babcb319db9dd b/regress/corpus/954eabc7f4915e55ab72abaae18babcb319db9dd
new file mode 100644
index 0000000..63bc5a3
--- /dev/null
+++ b/regress/corpus/954eabc7f4915e55ab72abaae18babcb319db9dd
@@ -0,0 +1 @@
+¹¹¹ÿÿÿÿÿÿÿ`ÿÿÿ2ÖÖÿÿÿÿ`ÿÿÿ2ÖÖÿ`ÿÿÿ2ÖÖÿÿÿÿ`ÿÿÿ2ÖÖÖÖÖÖÖÖÿÿÿÿÖÖÖÖÖÿÿÿÿÿ
\ No newline at end of file
diff --git a/regress/corpus/954f6e2ab929a0af1e9e6219dc94436889af5afe b/regress/corpus/954f6e2ab929a0af1e9e6219dc94436889af5afe
new file mode 100644
index 0000000..1286688
Binary files /dev/null and b/regress/corpus/954f6e2ab929a0af1e9e6219dc94436889af5afe differ
diff --git a/regress/corpus/95750b926efdc74598dd99ac2e3e6546112ffb56 b/regress/corpus/95750b926efdc74598dd99ac2e3e6546112ffb56
new file mode 100644
index 0000000..759a121
--- /dev/null
+++ b/regress/corpus/95750b926efdc74598dd99ac2e3e6546112ffb56
@@ -0,0 +1 @@
+¢ÿ]ÿþÿþ¡

\ No newline at end of file
diff --git a/regress/corpus/95842eec56c4339b26a57667f0edb733ed7962c0 b/regress/corpus/95842eec56c4339b26a57667f0edb733ed7962c0
new file mode 100644
index 0000000..a33aee5
Binary files /dev/null and b/regress/corpus/95842eec56c4339b26a57667f0edb733ed7962c0 differ
diff --git a/regress/corpus/95cd58cb7fe10654007d4484d7ce3ca4ecea0b02 b/regress/corpus/95cd58cb7fe10654007d4484d7ce3ca4ecea0b02
new file mode 100644
index 0000000..0651cb1
Binary files /dev/null and b/regress/corpus/95cd58cb7fe10654007d4484d7ce3ca4ecea0b02 differ
diff --git a/regress/corpus/96b0b73ccd4c4cbb53ddb0f34d6479952a99062a b/regress/corpus/96b0b73ccd4c4cbb53ddb0f34d6479952a99062a
new file mode 100644
index 0000000..3be1f9a
Binary files /dev/null and b/regress/corpus/96b0b73ccd4c4cbb53ddb0f34d6479952a99062a differ
diff --git a/regress/corpus/96bbaab1e049a90347a9f8fae767154ac8067c3b b/regress/corpus/96bbaab1e049a90347a9f8fae767154ac8067c3b
new file mode 100644
index 0000000..48752da
Binary files /dev/null and b/regress/corpus/96bbaab1e049a90347a9f8fae767154ac8067c3b differ
diff --git a/regress/corpus/970240906e2ee951475d085d068a3d094d41c19d b/regress/corpus/970240906e2ee951475d085d068a3d094d41c19d
new file mode 100644
index 0000000..03e018d
Binary files /dev/null and b/regress/corpus/970240906e2ee951475d085d068a3d094d41c19d differ
diff --git a/regress/corpus/975fb84d4c49e7e94a68f67199af8bcbb7a207fb b/regress/corpus/975fb84d4c49e7e94a68f67199af8bcbb7a207fb
new file mode 100644
index 0000000..491e513
Binary files /dev/null and b/regress/corpus/975fb84d4c49e7e94a68f67199af8bcbb7a207fb differ
diff --git a/regress/corpus/97a7c440eb6edd3b97857f170a22aaf745c2be08 b/regress/corpus/97a7c440eb6edd3b97857f170a22aaf745c2be08
new file mode 100644
index 0000000..9b9ee7a
Binary files /dev/null and b/regress/corpus/97a7c440eb6edd3b97857f170a22aaf745c2be08 differ
diff --git a/regress/corpus/97c9f5b01a64608c4d733fb5e8f80bf60cb6e0e9 b/regress/corpus/97c9f5b01a64608c4d733fb5e8f80bf60cb6e0e9
new file mode 100644
index 0000000..7d59f2d
Binary files /dev/null and b/regress/corpus/97c9f5b01a64608c4d733fb5e8f80bf60cb6e0e9 differ
diff --git a/regress/corpus/9824b77161124c1a52a0e90bcdcdf3e3315136ad b/regress/corpus/9824b77161124c1a52a0e90bcdcdf3e3315136ad
new file mode 100644
index 0000000..8e1fa1b
Binary files /dev/null and b/regress/corpus/9824b77161124c1a52a0e90bcdcdf3e3315136ad differ
diff --git a/regress/corpus/98b0978fd55ec45c2420efcb1fefaf176272e83b b/regress/corpus/98b0978fd55ec45c2420efcb1fefaf176272e83b
new file mode 100644
index 0000000..ad3f06a
--- /dev/null
+++ b/regress/corpus/98b0978fd55ec45c2420efcb1fefaf176272e83b
@@ -0,0 +1 @@
+	¹
\ No newline at end of file
diff --git a/regress/corpus/98b7dbc6b57999b18ac60f6c5cbefa9e8b7c1f27 b/regress/corpus/98b7dbc6b57999b18ac60f6c5cbefa9e8b7c1f27
new file mode 100644
index 0000000..5622580
Binary files /dev/null and b/regress/corpus/98b7dbc6b57999b18ac60f6c5cbefa9e8b7c1f27 differ
diff --git a/regress/corpus/98d479ca70fb1e102e8bbeeb6a60cc7fa3b76800 b/regress/corpus/98d479ca70fb1e102e8bbeeb6a60cc7fa3b76800
new file mode 100644
index 0000000..18b7112
Binary files /dev/null and b/regress/corpus/98d479ca70fb1e102e8bbeeb6a60cc7fa3b76800 differ
diff --git a/regress/corpus/98eec35d35186ca0ab0f9e20f98be54e56711755 b/regress/corpus/98eec35d35186ca0ab0f9e20f98be54e56711755
new file mode 100644
index 0000000..549f2b1
Binary files /dev/null and b/regress/corpus/98eec35d35186ca0ab0f9e20f98be54e56711755 differ
diff --git a/regress/corpus/990508507c525656ed05f2a24097542b86861947 b/regress/corpus/990508507c525656ed05f2a24097542b86861947
new file mode 100644
index 0000000..af9a36c
Binary files /dev/null and b/regress/corpus/990508507c525656ed05f2a24097542b86861947 differ
diff --git a/regress/corpus/99068925f5d3f8a1b72f2d994a1b83553734544c b/regress/corpus/99068925f5d3f8a1b72f2d994a1b83553734544c
new file mode 100644
index 0000000..5fba9a9
Binary files /dev/null and b/regress/corpus/99068925f5d3f8a1b72f2d994a1b83553734544c differ
diff --git a/regress/corpus/9915366692cdbe8b59686f62dc43376484d0997e b/regress/corpus/9915366692cdbe8b59686f62dc43376484d0997e
new file mode 100644
index 0000000..9a4c072
Binary files /dev/null and b/regress/corpus/9915366692cdbe8b59686f62dc43376484d0997e differ
diff --git a/regress/corpus/999e07e69be47a6d9b79b16ac0acc4d6f364389e b/regress/corpus/999e07e69be47a6d9b79b16ac0acc4d6f364389e
new file mode 100644
index 0000000..324a898
Binary files /dev/null and b/regress/corpus/999e07e69be47a6d9b79b16ac0acc4d6f364389e differ
diff --git a/regress/corpus/99c1fd892daa54d32498d85a1f553dcd5c4c4b38 b/regress/corpus/99c1fd892daa54d32498d85a1f553dcd5c4c4b38
new file mode 100644
index 0000000..bc8f935
Binary files /dev/null and b/regress/corpus/99c1fd892daa54d32498d85a1f553dcd5c4c4b38 differ
diff --git a/regress/corpus/99f928fab785bfe6b63ea25e4834a9b68ba69f07 b/regress/corpus/99f928fab785bfe6b63ea25e4834a9b68ba69f07
new file mode 100644
index 0000000..fe7f736
Binary files /dev/null and b/regress/corpus/99f928fab785bfe6b63ea25e4834a9b68ba69f07 differ
diff --git a/regress/corpus/9a438b14759dc939b246253f25dbd7cdcc18fc7b b/regress/corpus/9a438b14759dc939b246253f25dbd7cdcc18fc7b
new file mode 100644
index 0000000..256c285
Binary files /dev/null and b/regress/corpus/9a438b14759dc939b246253f25dbd7cdcc18fc7b differ
diff --git a/regress/corpus/9adddc94238e63de11effe112ff2ce714aa9a1f1 b/regress/corpus/9adddc94238e63de11effe112ff2ce714aa9a1f1
new file mode 100644
index 0000000..2f29174
Binary files /dev/null and b/regress/corpus/9adddc94238e63de11effe112ff2ce714aa9a1f1 differ
diff --git a/regress/corpus/9af47a3a40bf5249e12e0b2890f1f7c81b0ddfc1 b/regress/corpus/9af47a3a40bf5249e12e0b2890f1f7c81b0ddfc1
new file mode 100644
index 0000000..32a0028
Binary files /dev/null and b/regress/corpus/9af47a3a40bf5249e12e0b2890f1f7c81b0ddfc1 differ
diff --git a/regress/corpus/9b3d11c3f1e4e115b3efa17a9f38879c0a381a20 b/regress/corpus/9b3d11c3f1e4e115b3efa17a9f38879c0a381a20
new file mode 100644
index 0000000..36d6c00
Binary files /dev/null and b/regress/corpus/9b3d11c3f1e4e115b3efa17a9f38879c0a381a20 differ
diff --git a/regress/corpus/9bb9a330f03a065caff0118814fd5696533a4e23 b/regress/corpus/9bb9a330f03a065caff0118814fd5696533a4e23
new file mode 100644
index 0000000..fc8d882
Binary files /dev/null and b/regress/corpus/9bb9a330f03a065caff0118814fd5696533a4e23 differ
diff --git a/regress/corpus/9bcade36d87f3c9af4127e921d669d812fca89f6 b/regress/corpus/9bcade36d87f3c9af4127e921d669d812fca89f6
new file mode 100644
index 0000000..4b20029
Binary files /dev/null and b/regress/corpus/9bcade36d87f3c9af4127e921d669d812fca89f6 differ
diff --git a/regress/corpus/9c7874f89f89c284b0d44cf008c86e5c199ee323 b/regress/corpus/9c7874f89f89c284b0d44cf008c86e5c199ee323
new file mode 100644
index 0000000..cb56b56
--- /dev/null
+++ b/regress/corpus/9c7874f89f89c284b0d44cf008c86e5c199ee323
@@ -0,0 +1 @@
+Y¢
\ No newline at end of file
diff --git a/regress/corpus/9c92687eedbfd81891c7d469f760a798e7b1e214 b/regress/corpus/9c92687eedbfd81891c7d469f760a798e7b1e214
new file mode 100644
index 0000000..c016b51
Binary files /dev/null and b/regress/corpus/9c92687eedbfd81891c7d469f760a798e7b1e214 differ
diff --git a/regress/corpus/9ccf68d691cc61583a06a46a31e783678a7b16ff b/regress/corpus/9ccf68d691cc61583a06a46a31e783678a7b16ff
new file mode 100644
index 0000000..a9c95e0
Binary files /dev/null and b/regress/corpus/9ccf68d691cc61583a06a46a31e783678a7b16ff differ
diff --git a/regress/corpus/9cd35d0bed4ed8ae1933a4f32458bca0e93b10d8 b/regress/corpus/9cd35d0bed4ed8ae1933a4f32458bca0e93b10d8
new file mode 100644
index 0000000..0a867ff
Binary files /dev/null and b/regress/corpus/9cd35d0bed4ed8ae1933a4f32458bca0e93b10d8 differ
diff --git a/regress/corpus/9ce1604d659135925ccc4dd1f526affe42e689f1 b/regress/corpus/9ce1604d659135925ccc4dd1f526affe42e689f1
new file mode 100644
index 0000000..f71ac66
Binary files /dev/null and b/regress/corpus/9ce1604d659135925ccc4dd1f526affe42e689f1 differ
diff --git a/regress/corpus/9e4d5a788372d861bb193741b5033b188869acd9 b/regress/corpus/9e4d5a788372d861bb193741b5033b188869acd9
new file mode 100644
index 0000000..8376b0d
Binary files /dev/null and b/regress/corpus/9e4d5a788372d861bb193741b5033b188869acd9 differ
diff --git a/regress/corpus/9e6bc59c61cfe7e36f004d27ba4bc87cc35e4b49 b/regress/corpus/9e6bc59c61cfe7e36f004d27ba4bc87cc35e4b49
new file mode 100644
index 0000000..98974dd
Binary files /dev/null and b/regress/corpus/9e6bc59c61cfe7e36f004d27ba4bc87cc35e4b49 differ
diff --git a/regress/corpus/9e9a97a4c622249a1a069406b63cd776cd14ae4e b/regress/corpus/9e9a97a4c622249a1a069406b63cd776cd14ae4e
new file mode 100644
index 0000000..eec7b7a
Binary files /dev/null and b/regress/corpus/9e9a97a4c622249a1a069406b63cd776cd14ae4e differ
diff --git a/regress/corpus/9f3b8883526aa4009a4c7fecf96fdf9a9fcd5528 b/regress/corpus/9f3b8883526aa4009a4c7fecf96fdf9a9fcd5528
new file mode 100644
index 0000000..54a1ef1
Binary files /dev/null and b/regress/corpus/9f3b8883526aa4009a4c7fecf96fdf9a9fcd5528 differ
diff --git a/regress/corpus/9f59a0992a5aa733842f62deba316fbeaba95d22 b/regress/corpus/9f59a0992a5aa733842f62deba316fbeaba95d22
new file mode 100644
index 0000000..9c1a381
Binary files /dev/null and b/regress/corpus/9f59a0992a5aa733842f62deba316fbeaba95d22 differ
diff --git a/regress/corpus/a0325e78550fa53de9eb4f8ec7191080143041fe b/regress/corpus/a0325e78550fa53de9eb4f8ec7191080143041fe
new file mode 100644
index 0000000..45492db
Binary files /dev/null and b/regress/corpus/a0325e78550fa53de9eb4f8ec7191080143041fe differ
diff --git a/regress/corpus/a0599f71cd2b664b9c403ebce915dbc3c1f2bb0c b/regress/corpus/a0599f71cd2b664b9c403ebce915dbc3c1f2bb0c
new file mode 100644
index 0000000..19450b2
Binary files /dev/null and b/regress/corpus/a0599f71cd2b664b9c403ebce915dbc3c1f2bb0c differ
diff --git a/regress/corpus/a0fd0cd2c64fbcfa550512560c6e00c099f9aacc b/regress/corpus/a0fd0cd2c64fbcfa550512560c6e00c099f9aacc
new file mode 100644
index 0000000..51bc746
Binary files /dev/null and b/regress/corpus/a0fd0cd2c64fbcfa550512560c6e00c099f9aacc differ
diff --git a/regress/corpus/a10c77a48789c09c1c4f6c50e00c94955edd1d10 b/regress/corpus/a10c77a48789c09c1c4f6c50e00c94955edd1d10
new file mode 100644
index 0000000..25c53ef
Binary files /dev/null and b/regress/corpus/a10c77a48789c09c1c4f6c50e00c94955edd1d10 differ
diff --git a/regress/corpus/a1c29609317113f78ac9f634fc9a19958abb138f b/regress/corpus/a1c29609317113f78ac9f634fc9a19958abb138f
new file mode 100644
index 0000000..5a2e5a1
Binary files /dev/null and b/regress/corpus/a1c29609317113f78ac9f634fc9a19958abb138f differ
diff --git a/regress/corpus/a26b14bf845f39cd55a68a2e8c20c6ac0236cf09 b/regress/corpus/a26b14bf845f39cd55a68a2e8c20c6ac0236cf09
new file mode 100644
index 0000000..126c85e
Binary files /dev/null and b/regress/corpus/a26b14bf845f39cd55a68a2e8c20c6ac0236cf09 differ
diff --git a/regress/corpus/a2f7290b0387a503460cd2ea0a949689c78f4204 b/regress/corpus/a2f7290b0387a503460cd2ea0a949689c78f4204
new file mode 100644
index 0000000..d5b8fe7
Binary files /dev/null and b/regress/corpus/a2f7290b0387a503460cd2ea0a949689c78f4204 differ
diff --git a/regress/corpus/a2fb72fd3996f6da4e4b705e735290d918104606 b/regress/corpus/a2fb72fd3996f6da4e4b705e735290d918104606
new file mode 100644
index 0000000..4f38f16
Binary files /dev/null and b/regress/corpus/a2fb72fd3996f6da4e4b705e735290d918104606 differ
diff --git a/regress/corpus/a3aa5727e4969801c7ce25c0e5a3b893a3598a73 b/regress/corpus/a3aa5727e4969801c7ce25c0e5a3b893a3598a73
new file mode 100644
index 0000000..df0ca06
Binary files /dev/null and b/regress/corpus/a3aa5727e4969801c7ce25c0e5a3b893a3598a73 differ
diff --git a/regress/corpus/a3c57d6371bc722974d303e46c493db32028d7ec b/regress/corpus/a3c57d6371bc722974d303e46c493db32028d7ec
new file mode 100644
index 0000000..015002e
Binary files /dev/null and b/regress/corpus/a3c57d6371bc722974d303e46c493db32028d7ec differ
diff --git a/regress/corpus/a3ed2b59b7950022a048b6d67dbac1af4d8a7f0f b/regress/corpus/a3ed2b59b7950022a048b6d67dbac1af4d8a7f0f
new file mode 100644
index 0000000..91ff342
Binary files /dev/null and b/regress/corpus/a3ed2b59b7950022a048b6d67dbac1af4d8a7f0f differ
diff --git a/regress/corpus/a40b2149f78ef7b33edf90b68f87cff8f2aff2b7 b/regress/corpus/a40b2149f78ef7b33edf90b68f87cff8f2aff2b7
new file mode 100644
index 0000000..345bbc3
Binary files /dev/null and b/regress/corpus/a40b2149f78ef7b33edf90b68f87cff8f2aff2b7 differ
diff --git a/regress/corpus/a4b1e09fd4b041a945d45035ca6c5b7d6def39fe b/regress/corpus/a4b1e09fd4b041a945d45035ca6c5b7d6def39fe
new file mode 100644
index 0000000..b41c155
Binary files /dev/null and b/regress/corpus/a4b1e09fd4b041a945d45035ca6c5b7d6def39fe differ
diff --git a/regress/corpus/a5b63f7e9ca957c116955db09d5b68d3e2b37862 b/regress/corpus/a5b63f7e9ca957c116955db09d5b68d3e2b37862
new file mode 100644
index 0000000..316d93e
--- /dev/null
+++ b/regress/corpus/a5b63f7e9ca957c116955db09d5b68d3e2b37862
@@ -0,0 +1 @@
+  
ÿý&
\ No newline at end of file
diff --git a/regress/corpus/a65656539585ed8898d3063d6a3a3b816e6539c7 b/regress/corpus/a65656539585ed8898d3063d6a3a3b816e6539c7
new file mode 100644
index 0000000..98e7dd6
Binary files /dev/null and b/regress/corpus/a65656539585ed8898d3063d6a3a3b816e6539c7 differ
diff --git a/regress/corpus/a68e5160505fab79ba7253249e55d9f9c350ce90 b/regress/corpus/a68e5160505fab79ba7253249e55d9f9c350ce90
new file mode 100644
index 0000000..9daede0
Binary files /dev/null and b/regress/corpus/a68e5160505fab79ba7253249e55d9f9c350ce90 differ
diff --git a/regress/corpus/a6b345c8a480ac7f60d53332eb7b2d4ead9f825a b/regress/corpus/a6b345c8a480ac7f60d53332eb7b2d4ead9f825a
new file mode 100644
index 0000000..87f317b
Binary files /dev/null and b/regress/corpus/a6b345c8a480ac7f60d53332eb7b2d4ead9f825a differ
diff --git a/regress/corpus/a6ed0c1810a5d697a7843341e8ebd728944940e7 b/regress/corpus/a6ed0c1810a5d697a7843341e8ebd728944940e7
new file mode 100644
index 0000000..ae71907
Binary files /dev/null and b/regress/corpus/a6ed0c1810a5d697a7843341e8ebd728944940e7 differ
diff --git a/regress/corpus/a78797805a55b6c8414d0a25c186392f2e8c4c2c b/regress/corpus/a78797805a55b6c8414d0a25c186392f2e8c4c2c
new file mode 100644
index 0000000..47b9db1
Binary files /dev/null and b/regress/corpus/a78797805a55b6c8414d0a25c186392f2e8c4c2c differ
diff --git a/regress/corpus/a7a93d84b948364645d95cdad57eac52b849535d b/regress/corpus/a7a93d84b948364645d95cdad57eac52b849535d
new file mode 100644
index 0000000..75386a0
Binary files /dev/null and b/regress/corpus/a7a93d84b948364645d95cdad57eac52b849535d differ
diff --git a/regress/corpus/a7bd988e4fd6abe3f746583c2ef0e9ddb3840e93 b/regress/corpus/a7bd988e4fd6abe3f746583c2ef0e9ddb3840e93
new file mode 100644
index 0000000..142ffde
Binary files /dev/null and b/regress/corpus/a7bd988e4fd6abe3f746583c2ef0e9ddb3840e93 differ
diff --git a/regress/corpus/a7c9344ca7b2dfb694854a0f35a0d7d4b35e4804 b/regress/corpus/a7c9344ca7b2dfb694854a0f35a0d7d4b35e4804
new file mode 100644
index 0000000..6d24a7c
Binary files /dev/null and b/regress/corpus/a7c9344ca7b2dfb694854a0f35a0d7d4b35e4804 differ
diff --git a/regress/corpus/a7dfaff0f9843772735c0a4bc43e6cbc5ac9f323 b/regress/corpus/a7dfaff0f9843772735c0a4bc43e6cbc5ac9f323
new file mode 100644
index 0000000..2261c47
Binary files /dev/null and b/regress/corpus/a7dfaff0f9843772735c0a4bc43e6cbc5ac9f323 differ
diff --git a/regress/corpus/a7e26305de62e741962b6452e706252aa5f7ca3a b/regress/corpus/a7e26305de62e741962b6452e706252aa5f7ca3a
new file mode 100644
index 0000000..cb14434
Binary files /dev/null and b/regress/corpus/a7e26305de62e741962b6452e706252aa5f7ca3a differ
diff --git a/regress/corpus/a80e73ca501e9987103ce87189cf5f7d52f10028 b/regress/corpus/a80e73ca501e9987103ce87189cf5f7d52f10028
new file mode 100644
index 0000000..60e9f1c
Binary files /dev/null and b/regress/corpus/a80e73ca501e9987103ce87189cf5f7d52f10028 differ
diff --git a/regress/corpus/a8216f66bbbe6994762f4f141d395188c41ebf2a b/regress/corpus/a8216f66bbbe6994762f4f141d395188c41ebf2a
new file mode 100644
index 0000000..71e199c
Binary files /dev/null and b/regress/corpus/a8216f66bbbe6994762f4f141d395188c41ebf2a differ
diff --git a/regress/corpus/a9745a45eac355f6ac3bee8ad0b35e680e8f964c b/regress/corpus/a9745a45eac355f6ac3bee8ad0b35e680e8f964c
new file mode 100644
index 0000000..96b83c5
Binary files /dev/null and b/regress/corpus/a9745a45eac355f6ac3bee8ad0b35e680e8f964c differ
diff --git a/regress/corpus/a99586555b9fbfb4389df04d2d523725059fa433 b/regress/corpus/a99586555b9fbfb4389df04d2d523725059fa433
new file mode 100644
index 0000000..62435c8
Binary files /dev/null and b/regress/corpus/a99586555b9fbfb4389df04d2d523725059fa433 differ
diff --git a/regress/corpus/a9b8840dafc6c214c23c575adcf706c4f3c14413 b/regress/corpus/a9b8840dafc6c214c23c575adcf706c4f3c14413
new file mode 100644
index 0000000..a2533cd
Binary files /dev/null and b/regress/corpus/a9b8840dafc6c214c23c575adcf706c4f3c14413 differ
diff --git a/regress/corpus/aa46f107a61179b8898044343e4631373a1eea53 b/regress/corpus/aa46f107a61179b8898044343e4631373a1eea53
new file mode 100644
index 0000000..031b91f
Binary files /dev/null and b/regress/corpus/aa46f107a61179b8898044343e4631373a1eea53 differ
diff --git a/regress/corpus/aa7513e9789339b47b881855c444d6b9719dbac0 b/regress/corpus/aa7513e9789339b47b881855c444d6b9719dbac0
new file mode 100644
index 0000000..6a4752b
Binary files /dev/null and b/regress/corpus/aa7513e9789339b47b881855c444d6b9719dbac0 differ
diff --git a/regress/corpus/aadf3b1901e69ae278397f522411352eee3e60fc b/regress/corpus/aadf3b1901e69ae278397f522411352eee3e60fc
new file mode 100644
index 0000000..4559b90
Binary files /dev/null and b/regress/corpus/aadf3b1901e69ae278397f522411352eee3e60fc differ
diff --git a/regress/corpus/ab3382ad0d5ab6367b488ae1478373c7bb60fc3e b/regress/corpus/ab3382ad0d5ab6367b488ae1478373c7bb60fc3e
new file mode 100644
index 0000000..8e03120
Binary files /dev/null and b/regress/corpus/ab3382ad0d5ab6367b488ae1478373c7bb60fc3e differ
diff --git a/regress/corpus/ab5852763202f606306d339f8d65ae56ec04a066 b/regress/corpus/ab5852763202f606306d339f8d65ae56ec04a066
new file mode 100644
index 0000000..7673ad6
Binary files /dev/null and b/regress/corpus/ab5852763202f606306d339f8d65ae56ec04a066 differ
diff --git a/regress/corpus/abcfba43f31a70d4e58451c1d0f81de5fe4fcae2 b/regress/corpus/abcfba43f31a70d4e58451c1d0f81de5fe4fcae2
new file mode 100644
index 0000000..bf5e530
Binary files /dev/null and b/regress/corpus/abcfba43f31a70d4e58451c1d0f81de5fe4fcae2 differ
diff --git a/regress/corpus/abe4c4ce5c010acaf25f918a10488607555a91aa b/regress/corpus/abe4c4ce5c010acaf25f918a10488607555a91aa
new file mode 100644
index 0000000..e129e04
Binary files /dev/null and b/regress/corpus/abe4c4ce5c010acaf25f918a10488607555a91aa differ
diff --git a/regress/corpus/abf885332d343205410c7b0cd718012471865a33 b/regress/corpus/abf885332d343205410c7b0cd718012471865a33
new file mode 100644
index 0000000..04871ca
Binary files /dev/null and b/regress/corpus/abf885332d343205410c7b0cd718012471865a33 differ
diff --git a/regress/corpus/ac4bf8da6a8c6922aea26d10a7770ea5b005ce3f b/regress/corpus/ac4bf8da6a8c6922aea26d10a7770ea5b005ce3f
new file mode 100644
index 0000000..7ddf88a
Binary files /dev/null and b/regress/corpus/ac4bf8da6a8c6922aea26d10a7770ea5b005ce3f differ
diff --git a/regress/corpus/ac92118dcf23c98714781748676c6802b15d505e b/regress/corpus/ac92118dcf23c98714781748676c6802b15d505e
new file mode 100644
index 0000000..d258f2d
Binary files /dev/null and b/regress/corpus/ac92118dcf23c98714781748676c6802b15d505e differ
diff --git a/regress/corpus/acae5d16f58a6d3202e43a7ba8a8dc451c9fe83d b/regress/corpus/acae5d16f58a6d3202e43a7ba8a8dc451c9fe83d
new file mode 100644
index 0000000..d4bdf85
Binary files /dev/null and b/regress/corpus/acae5d16f58a6d3202e43a7ba8a8dc451c9fe83d differ
diff --git a/regress/corpus/acaec48a1cfb62715e720ab1b3a0caec012d95bf b/regress/corpus/acaec48a1cfb62715e720ab1b3a0caec012d95bf
new file mode 100644
index 0000000..1fd318e
Binary files /dev/null and b/regress/corpus/acaec48a1cfb62715e720ab1b3a0caec012d95bf differ
diff --git a/regress/corpus/acbdc9cfc833721f2d10f27fd760f4397f9294a8 b/regress/corpus/acbdc9cfc833721f2d10f27fd760f4397f9294a8
new file mode 100644
index 0000000..2cec9f5
Binary files /dev/null and b/regress/corpus/acbdc9cfc833721f2d10f27fd760f4397f9294a8 differ
diff --git a/regress/corpus/acd867ceb457ae8254326eb7c501d155d0cea672 b/regress/corpus/acd867ceb457ae8254326eb7c501d155d0cea672
new file mode 100644
index 0000000..d1107a9
Binary files /dev/null and b/regress/corpus/acd867ceb457ae8254326eb7c501d155d0cea672 differ
diff --git a/regress/corpus/ad00c7fe5bb9dd0380f866a7631d0617e7567bd9 b/regress/corpus/ad00c7fe5bb9dd0380f866a7631d0617e7567bd9
new file mode 100644
index 0000000..762b37d
--- /dev/null
+++ b/regress/corpus/ad00c7fe5bb9dd0380f866a7631d0617e7567bd9
@@ -0,0 +1 @@
+/þùŸ ¼¨sqþ
\ No newline at end of file
diff --git a/regress/corpus/ad07ecee596aa5c1210b851fa9810a2decd8bf99 b/regress/corpus/ad07ecee596aa5c1210b851fa9810a2decd8bf99
new file mode 100644
index 0000000..56d624d
Binary files /dev/null and b/regress/corpus/ad07ecee596aa5c1210b851fa9810a2decd8bf99 differ
diff --git a/regress/corpus/ad0c40ff1d5721d8b01f73454e06260207667d81 b/regress/corpus/ad0c40ff1d5721d8b01f73454e06260207667d81
new file mode 100644
index 0000000..4935d36
Binary files /dev/null and b/regress/corpus/ad0c40ff1d5721d8b01f73454e06260207667d81 differ
diff --git a/regress/corpus/ad22cc03ebb7577d29b889e5566dd2b0ef2419f7 b/regress/corpus/ad22cc03ebb7577d29b889e5566dd2b0ef2419f7
new file mode 100644
index 0000000..5e62c57
Binary files /dev/null and b/regress/corpus/ad22cc03ebb7577d29b889e5566dd2b0ef2419f7 differ
diff --git a/regress/corpus/ad9d8929a1e466127fad0c093d952a9bf34bf3bf b/regress/corpus/ad9d8929a1e466127fad0c093d952a9bf34bf3bf
new file mode 100644
index 0000000..d76c4ad
Binary files /dev/null and b/regress/corpus/ad9d8929a1e466127fad0c093d952a9bf34bf3bf differ
diff --git a/regress/corpus/addfeb57f1e2bb551505939b2ac68790a3a7ffd6 b/regress/corpus/addfeb57f1e2bb551505939b2ac68790a3a7ffd6
new file mode 100644
index 0000000..a1ab670
Binary files /dev/null and b/regress/corpus/addfeb57f1e2bb551505939b2ac68790a3a7ffd6 differ
diff --git a/regress/corpus/ae1772fd023f897b7f59e9f039cdea8268f757d9 b/regress/corpus/ae1772fd023f897b7f59e9f039cdea8268f757d9
new file mode 100644
index 0000000..9e4c061
Binary files /dev/null and b/regress/corpus/ae1772fd023f897b7f59e9f039cdea8268f757d9 differ
diff --git a/regress/corpus/ae2270662f6fb21cca3739ebaede36fcb763137a b/regress/corpus/ae2270662f6fb21cca3739ebaede36fcb763137a
new file mode 100644
index 0000000..6c58171
Binary files /dev/null and b/regress/corpus/ae2270662f6fb21cca3739ebaede36fcb763137a differ
diff --git a/regress/corpus/ae3f65080bf46aca7bafd1e129a2508ecd737dec b/regress/corpus/ae3f65080bf46aca7bafd1e129a2508ecd737dec
new file mode 100644
index 0000000..2d83423
Binary files /dev/null and b/regress/corpus/ae3f65080bf46aca7bafd1e129a2508ecd737dec differ
diff --git a/regress/corpus/ae48c9d1f1f3685ff3107b122ba281d4c4dc084b b/regress/corpus/ae48c9d1f1f3685ff3107b122ba281d4c4dc084b
new file mode 100644
index 0000000..2a03574
Binary files /dev/null and b/regress/corpus/ae48c9d1f1f3685ff3107b122ba281d4c4dc084b differ
diff --git a/regress/corpus/ae940b5ba0a8b47eeb3ff97e852fd369b1304196 b/regress/corpus/ae940b5ba0a8b47eeb3ff97e852fd369b1304196
new file mode 100644
index 0000000..bc4f05a
Binary files /dev/null and b/regress/corpus/ae940b5ba0a8b47eeb3ff97e852fd369b1304196 differ
diff --git a/regress/corpus/aed7cc67f73f2efcf63652cd85a1feacad555e16 b/regress/corpus/aed7cc67f73f2efcf63652cd85a1feacad555e16
new file mode 100644
index 0000000..9b26ab5
Binary files /dev/null and b/regress/corpus/aed7cc67f73f2efcf63652cd85a1feacad555e16 differ
diff --git a/regress/corpus/af1ec507d20c15585f88053a00090d47345b8305 b/regress/corpus/af1ec507d20c15585f88053a00090d47345b8305
new file mode 100644
index 0000000..a8f38d9
Binary files /dev/null and b/regress/corpus/af1ec507d20c15585f88053a00090d47345b8305 differ
diff --git a/regress/corpus/af2eff0b0b5f017869f4fca654e1a62960704db9 b/regress/corpus/af2eff0b0b5f017869f4fca654e1a62960704db9
new file mode 100644
index 0000000..586cecc
Binary files /dev/null and b/regress/corpus/af2eff0b0b5f017869f4fca654e1a62960704db9 differ
diff --git a/regress/corpus/af39af37db7a5cd26116d6438ff928b9002732be b/regress/corpus/af39af37db7a5cd26116d6438ff928b9002732be
new file mode 100644
index 0000000..e9e1323
Binary files /dev/null and b/regress/corpus/af39af37db7a5cd26116d6438ff928b9002732be differ
diff --git a/regress/corpus/af4335ef850e8dff2e243c9763b7e831f95b0884 b/regress/corpus/af4335ef850e8dff2e243c9763b7e831f95b0884
new file mode 100644
index 0000000..29b5ee2
Binary files /dev/null and b/regress/corpus/af4335ef850e8dff2e243c9763b7e831f95b0884 differ
diff --git a/regress/corpus/af488e737e65a06a3c5568b010b21e0e104232bf b/regress/corpus/af488e737e65a06a3c5568b010b21e0e104232bf
new file mode 100644
index 0000000..2a3048d
Binary files /dev/null and b/regress/corpus/af488e737e65a06a3c5568b010b21e0e104232bf differ
diff --git a/regress/corpus/af6686d48e1f6a4f8d739b1017a4aa4fc8baf384 b/regress/corpus/af6686d48e1f6a4f8d739b1017a4aa4fc8baf384
new file mode 100644
index 0000000..1b94229
Binary files /dev/null and b/regress/corpus/af6686d48e1f6a4f8d739b1017a4aa4fc8baf384 differ
diff --git a/regress/corpus/af6f39261913488276d4a2c058491e9a32bfabf7 b/regress/corpus/af6f39261913488276d4a2c058491e9a32bfabf7
new file mode 100644
index 0000000..0a05bc6
Binary files /dev/null and b/regress/corpus/af6f39261913488276d4a2c058491e9a32bfabf7 differ
diff --git a/regress/corpus/afb3e7c0c98741bb299eb3c9dfbff978e9204f6a b/regress/corpus/afb3e7c0c98741bb299eb3c9dfbff978e9204f6a
new file mode 100644
index 0000000..bab8782
Binary files /dev/null and b/regress/corpus/afb3e7c0c98741bb299eb3c9dfbff978e9204f6a differ
diff --git a/regress/corpus/afbc13987f873650de5ed88882f9823422ad5a5b b/regress/corpus/afbc13987f873650de5ed88882f9823422ad5a5b
new file mode 100644
index 0000000..edf0063
Binary files /dev/null and b/regress/corpus/afbc13987f873650de5ed88882f9823422ad5a5b differ
diff --git a/regress/corpus/aff3e4182a36de06fe672883c7e7cb6c4bf07d68 b/regress/corpus/aff3e4182a36de06fe672883c7e7cb6c4bf07d68
new file mode 100644
index 0000000..e4305c5
Binary files /dev/null and b/regress/corpus/aff3e4182a36de06fe672883c7e7cb6c4bf07d68 differ
diff --git a/regress/corpus/b022b321dc96a791e7432f1cefb9c6b4fb3ed8ad b/regress/corpus/b022b321dc96a791e7432f1cefb9c6b4fb3ed8ad
new file mode 100644
index 0000000..db15961
Binary files /dev/null and b/regress/corpus/b022b321dc96a791e7432f1cefb9c6b4fb3ed8ad differ
diff --git a/regress/corpus/b0302009ec735d2b6de0a29923829866d5612b5f b/regress/corpus/b0302009ec735d2b6de0a29923829866d5612b5f
new file mode 100644
index 0000000..ecb482a
Binary files /dev/null and b/regress/corpus/b0302009ec735d2b6de0a29923829866d5612b5f differ
diff --git a/regress/corpus/b04d30b01fc52e67be2bc25ed8ebd31d4a46d7fb b/regress/corpus/b04d30b01fc52e67be2bc25ed8ebd31d4a46d7fb
new file mode 100644
index 0000000..7a28628
Binary files /dev/null and b/regress/corpus/b04d30b01fc52e67be2bc25ed8ebd31d4a46d7fb differ
diff --git a/regress/corpus/b0aadeb9071b8fc80d5f194cba93874bcf67f286 b/regress/corpus/b0aadeb9071b8fc80d5f194cba93874bcf67f286
new file mode 100644
index 0000000..fad9328
Binary files /dev/null and b/regress/corpus/b0aadeb9071b8fc80d5f194cba93874bcf67f286 differ
diff --git a/regress/corpus/b0d0c50eb6925a152bcc155725546346a6245941 b/regress/corpus/b0d0c50eb6925a152bcc155725546346a6245941
new file mode 100644
index 0000000..c539059
Binary files /dev/null and b/regress/corpus/b0d0c50eb6925a152bcc155725546346a6245941 differ
diff --git a/regress/corpus/b0f147f1f41c34e4bc3bb3f80d65f2b6c07b71b9 b/regress/corpus/b0f147f1f41c34e4bc3bb3f80d65f2b6c07b71b9
new file mode 100644
index 0000000..a77df62
Binary files /dev/null and b/regress/corpus/b0f147f1f41c34e4bc3bb3f80d65f2b6c07b71b9 differ
diff --git a/regress/corpus/b168bcb4776297254332db0d72f5cbd611a99143 b/regress/corpus/b168bcb4776297254332db0d72f5cbd611a99143
new file mode 100644
index 0000000..b91105e
Binary files /dev/null and b/regress/corpus/b168bcb4776297254332db0d72f5cbd611a99143 differ
diff --git a/regress/corpus/b172d3d474bbd55ff3cf5846578a78bf91c59f46 b/regress/corpus/b172d3d474bbd55ff3cf5846578a78bf91c59f46
new file mode 100644
index 0000000..d4e1046
Binary files /dev/null and b/regress/corpus/b172d3d474bbd55ff3cf5846578a78bf91c59f46 differ
diff --git a/regress/corpus/b1e0969a15dfc06a9deb925dfa8dd72ff0832d32 b/regress/corpus/b1e0969a15dfc06a9deb925dfa8dd72ff0832d32
new file mode 100644
index 0000000..419d1c6
Binary files /dev/null and b/regress/corpus/b1e0969a15dfc06a9deb925dfa8dd72ff0832d32 differ
diff --git a/regress/corpus/b1fc7413d9261c25622febb0394d19fa1e14091e b/regress/corpus/b1fc7413d9261c25622febb0394d19fa1e14091e
new file mode 100644
index 0000000..68b35fa
Binary files /dev/null and b/regress/corpus/b1fc7413d9261c25622febb0394d19fa1e14091e differ
diff --git a/regress/corpus/b36dfb1f140e85136b25a40831f33f1f477b1ef7 b/regress/corpus/b36dfb1f140e85136b25a40831f33f1f477b1ef7
new file mode 100644
index 0000000..66c3c97
Binary files /dev/null and b/regress/corpus/b36dfb1f140e85136b25a40831f33f1f477b1ef7 differ
diff --git a/regress/corpus/b37982e22cc21cf0cbc0332b51678520fa20a1da b/regress/corpus/b37982e22cc21cf0cbc0332b51678520fa20a1da
new file mode 100644
index 0000000..cce05e4
Binary files /dev/null and b/regress/corpus/b37982e22cc21cf0cbc0332b51678520fa20a1da differ
diff --git a/regress/corpus/b39b30f79f1e0d1edb66ecc1dca749965eaa7bf9 b/regress/corpus/b39b30f79f1e0d1edb66ecc1dca749965eaa7bf9
new file mode 100644
index 0000000..72c22aa
Binary files /dev/null and b/regress/corpus/b39b30f79f1e0d1edb66ecc1dca749965eaa7bf9 differ
diff --git a/regress/corpus/b3d12afc294638efc98cdec12a9549557f1d6844 b/regress/corpus/b3d12afc294638efc98cdec12a9549557f1d6844
new file mode 100644
index 0000000..720ad42
Binary files /dev/null and b/regress/corpus/b3d12afc294638efc98cdec12a9549557f1d6844 differ
diff --git a/regress/corpus/b3e55e30bb7662846d920af14be6458c955f3dac b/regress/corpus/b3e55e30bb7662846d920af14be6458c955f3dac
new file mode 100644
index 0000000..8b6f004
Binary files /dev/null and b/regress/corpus/b3e55e30bb7662846d920af14be6458c955f3dac differ
diff --git a/regress/corpus/b3f5074e0b8e0f5f4622bb88d9369d12398ea668 b/regress/corpus/b3f5074e0b8e0f5f4622bb88d9369d12398ea668
new file mode 100644
index 0000000..b888335
Binary files /dev/null and b/regress/corpus/b3f5074e0b8e0f5f4622bb88d9369d12398ea668 differ
diff --git a/regress/corpus/b404cc9150b9853ed2400f58e466ff2eb7e4b362 b/regress/corpus/b404cc9150b9853ed2400f58e466ff2eb7e4b362
new file mode 100644
index 0000000..561aa3f
Binary files /dev/null and b/regress/corpus/b404cc9150b9853ed2400f58e466ff2eb7e4b362 differ
diff --git a/regress/corpus/b4ca7b7bf5100fe77b2c9b3c2ea773915e4a9d6e b/regress/corpus/b4ca7b7bf5100fe77b2c9b3c2ea773915e4a9d6e
new file mode 100644
index 0000000..a0ebe22
Binary files /dev/null and b/regress/corpus/b4ca7b7bf5100fe77b2c9b3c2ea773915e4a9d6e differ
diff --git a/regress/corpus/b4f2df5dedddc1e5f8a9486617ad79cbbbd2010b b/regress/corpus/b4f2df5dedddc1e5f8a9486617ad79cbbbd2010b
new file mode 100644
index 0000000..7d02cc0
Binary files /dev/null and b/regress/corpus/b4f2df5dedddc1e5f8a9486617ad79cbbbd2010b differ
diff --git a/regress/corpus/b502fd576ff834a6f70374fb4f1259921000de9a b/regress/corpus/b502fd576ff834a6f70374fb4f1259921000de9a
new file mode 100644
index 0000000..18d8e39
Binary files /dev/null and b/regress/corpus/b502fd576ff834a6f70374fb4f1259921000de9a differ
diff --git a/regress/corpus/b53f3fb7e17f57a159c8d084edbb2fc231383283 b/regress/corpus/b53f3fb7e17f57a159c8d084edbb2fc231383283
new file mode 100644
index 0000000..3c57a03
Binary files /dev/null and b/regress/corpus/b53f3fb7e17f57a159c8d084edbb2fc231383283 differ
diff --git a/regress/corpus/b6160d6e3987e61916f40c4dfb408881072da41d b/regress/corpus/b6160d6e3987e61916f40c4dfb408881072da41d
new file mode 100644
index 0000000..abccc8c
Binary files /dev/null and b/regress/corpus/b6160d6e3987e61916f40c4dfb408881072da41d differ
diff --git a/regress/corpus/b62044534a5b21f09fb8bb7ef761619eb1f96dd2 b/regress/corpus/b62044534a5b21f09fb8bb7ef761619eb1f96dd2
new file mode 100644
index 0000000..0be1ff9
Binary files /dev/null and b/regress/corpus/b62044534a5b21f09fb8bb7ef761619eb1f96dd2 differ
diff --git a/regress/corpus/b6556bcd64c670959b5eda5b562017e61c959c73 b/regress/corpus/b6556bcd64c670959b5eda5b562017e61c959c73
new file mode 100644
index 0000000..cde2c64
Binary files /dev/null and b/regress/corpus/b6556bcd64c670959b5eda5b562017e61c959c73 differ
diff --git a/regress/corpus/b6ba81343b6ab8baa99a7a9ce560623bda5f29b7 b/regress/corpus/b6ba81343b6ab8baa99a7a9ce560623bda5f29b7
new file mode 100644
index 0000000..42c207b
Binary files /dev/null and b/regress/corpus/b6ba81343b6ab8baa99a7a9ce560623bda5f29b7 differ
diff --git a/regress/corpus/b6c79df70615f571647de60b1faba4585a0f6341 b/regress/corpus/b6c79df70615f571647de60b1faba4585a0f6341
new file mode 100644
index 0000000..72f9b5f
Binary files /dev/null and b/regress/corpus/b6c79df70615f571647de60b1faba4585a0f6341 differ
diff --git a/regress/corpus/b742c8cb092e1513b2289332fcea9c7ef44739f2 b/regress/corpus/b742c8cb092e1513b2289332fcea9c7ef44739f2
new file mode 100644
index 0000000..e264c98
Binary files /dev/null and b/regress/corpus/b742c8cb092e1513b2289332fcea9c7ef44739f2 differ
diff --git a/regress/corpus/b75666785dd0bfa53606a2c6f5a74d2ef87fa58a b/regress/corpus/b75666785dd0bfa53606a2c6f5a74d2ef87fa58a
new file mode 100644
index 0000000..2da544a
Binary files /dev/null and b/regress/corpus/b75666785dd0bfa53606a2c6f5a74d2ef87fa58a differ
diff --git a/regress/corpus/b7a9f1ef2b417627083ca0e3c01576f970047a10 b/regress/corpus/b7a9f1ef2b417627083ca0e3c01576f970047a10
new file mode 100644
index 0000000..706ef88
Binary files /dev/null and b/regress/corpus/b7a9f1ef2b417627083ca0e3c01576f970047a10 differ
diff --git a/regress/corpus/b7c446a931fd7dc25f359d96862796c053774271 b/regress/corpus/b7c446a931fd7dc25f359d96862796c053774271
new file mode 100644
index 0000000..504814e
Binary files /dev/null and b/regress/corpus/b7c446a931fd7dc25f359d96862796c053774271 differ
diff --git a/regress/corpus/b802142d13b66385996c9a3dfd6b0c4cd6a75870 b/regress/corpus/b802142d13b66385996c9a3dfd6b0c4cd6a75870
new file mode 100644
index 0000000..80c7464
Binary files /dev/null and b/regress/corpus/b802142d13b66385996c9a3dfd6b0c4cd6a75870 differ
diff --git a/regress/corpus/b806aa2487f8de774e92ce94603761e9f2c04e06 b/regress/corpus/b806aa2487f8de774e92ce94603761e9f2c04e06
new file mode 100644
index 0000000..6759dde
Binary files /dev/null and b/regress/corpus/b806aa2487f8de774e92ce94603761e9f2c04e06 differ
diff --git a/regress/corpus/b82a81912601d23807c10af4268fdad450c7c7c5 b/regress/corpus/b82a81912601d23807c10af4268fdad450c7c7c5
new file mode 100644
index 0000000..ca8d7b3
Binary files /dev/null and b/regress/corpus/b82a81912601d23807c10af4268fdad450c7c7c5 differ
diff --git a/regress/corpus/b855290b7801979f528ea28a6791aa67b38e1920 b/regress/corpus/b855290b7801979f528ea28a6791aa67b38e1920
new file mode 100644
index 0000000..3e9c5a8
Binary files /dev/null and b/regress/corpus/b855290b7801979f528ea28a6791aa67b38e1920 differ
diff --git a/regress/corpus/b88c33da68797d26661b0223bc118bf16fb4fe4f b/regress/corpus/b88c33da68797d26661b0223bc118bf16fb4fe4f
new file mode 100644
index 0000000..dec2015
Binary files /dev/null and b/regress/corpus/b88c33da68797d26661b0223bc118bf16fb4fe4f differ
diff --git a/regress/corpus/b90239fd820cc862a0aa25adea74bbfb50ab2a6f b/regress/corpus/b90239fd820cc862a0aa25adea74bbfb50ab2a6f
new file mode 100644
index 0000000..86450ae
Binary files /dev/null and b/regress/corpus/b90239fd820cc862a0aa25adea74bbfb50ab2a6f differ
diff --git a/regress/corpus/b93d354cf1b750a6031980d7875f724efaad99cb b/regress/corpus/b93d354cf1b750a6031980d7875f724efaad99cb
new file mode 100644
index 0000000..ae35816
Binary files /dev/null and b/regress/corpus/b93d354cf1b750a6031980d7875f724efaad99cb differ
diff --git a/regress/corpus/b96cd06a07aa2ea4cacfa5b7c374a4e1982b7837 b/regress/corpus/b96cd06a07aa2ea4cacfa5b7c374a4e1982b7837
new file mode 100644
index 0000000..7c32a82
Binary files /dev/null and b/regress/corpus/b96cd06a07aa2ea4cacfa5b7c374a4e1982b7837 differ
diff --git a/regress/corpus/b9db948517099d516de0284b2f1a3ecd293086a1 b/regress/corpus/b9db948517099d516de0284b2f1a3ecd293086a1
new file mode 100644
index 0000000..50a3ec4
Binary files /dev/null and b/regress/corpus/b9db948517099d516de0284b2f1a3ecd293086a1 differ
diff --git a/regress/corpus/ba1202ecaadf38968356a7132d0c68961184961d b/regress/corpus/ba1202ecaadf38968356a7132d0c68961184961d
new file mode 100644
index 0000000..f6fbf24
Binary files /dev/null and b/regress/corpus/ba1202ecaadf38968356a7132d0c68961184961d differ
diff --git a/regress/corpus/ba2c8050d36531e21af24eb4154e8e771f9885fe b/regress/corpus/ba2c8050d36531e21af24eb4154e8e771f9885fe
new file mode 100644
index 0000000..66ce6f8
Binary files /dev/null and b/regress/corpus/ba2c8050d36531e21af24eb4154e8e771f9885fe differ
diff --git a/regress/corpus/ba3bd70a25f8a3f5a3f88856124872545e6f9db1 b/regress/corpus/ba3bd70a25f8a3f5a3f88856124872545e6f9db1
new file mode 100644
index 0000000..3379407
Binary files /dev/null and b/regress/corpus/ba3bd70a25f8a3f5a3f88856124872545e6f9db1 differ
diff --git a/regress/corpus/ba8579bb0ac8a69bff6466bc60550fff46137a95 b/regress/corpus/ba8579bb0ac8a69bff6466bc60550fff46137a95
new file mode 100644
index 0000000..a33796a
Binary files /dev/null and b/regress/corpus/ba8579bb0ac8a69bff6466bc60550fff46137a95 differ
diff --git a/regress/corpus/baaddd35c814737a4f27e87d2b5363b795d958e4 b/regress/corpus/baaddd35c814737a4f27e87d2b5363b795d958e4
new file mode 100644
index 0000000..6f20e06
Binary files /dev/null and b/regress/corpus/baaddd35c814737a4f27e87d2b5363b795d958e4 differ
diff --git a/regress/corpus/bab488fece4736c97a7b53a3f60ad95c50800559 b/regress/corpus/bab488fece4736c97a7b53a3f60ad95c50800559
new file mode 100644
index 0000000..19460ca
Binary files /dev/null and b/regress/corpus/bab488fece4736c97a7b53a3f60ad95c50800559 differ
diff --git a/regress/corpus/basic_query.bin b/regress/corpus/basic_query.bin
new file mode 100644
index 0000000..81b6e3c
Binary files /dev/null and b/regress/corpus/basic_query.bin differ
diff --git a/regress/corpus/bb801edfcf2761d81a1e3e87e7f4e8defebebaf0 b/regress/corpus/bb801edfcf2761d81a1e3e87e7f4e8defebebaf0
new file mode 100644
index 0000000..5873d8e
Binary files /dev/null and b/regress/corpus/bb801edfcf2761d81a1e3e87e7f4e8defebebaf0 differ
diff --git a/regress/corpus/bb8f106fe97c546ad80c1f69ce605deee60e3c6c b/regress/corpus/bb8f106fe97c546ad80c1f69ce605deee60e3c6c
new file mode 100644
index 0000000..d6d37ed
Binary files /dev/null and b/regress/corpus/bb8f106fe97c546ad80c1f69ce605deee60e3c6c differ
diff --git a/regress/corpus/bba9f3584e6fa7dbcb51fac4fa8e387915d6a757 b/regress/corpus/bba9f3584e6fa7dbcb51fac4fa8e387915d6a757
new file mode 100644
index 0000000..c30f69b
Binary files /dev/null and b/regress/corpus/bba9f3584e6fa7dbcb51fac4fa8e387915d6a757 differ
diff --git a/regress/corpus/bbda044b8efddca40bfa624d5f276a0abd397b3a b/regress/corpus/bbda044b8efddca40bfa624d5f276a0abd397b3a
new file mode 100644
index 0000000..a52180c
Binary files /dev/null and b/regress/corpus/bbda044b8efddca40bfa624d5f276a0abd397b3a differ
diff --git a/regress/corpus/bbf23d7a922eb1af713698b5d0a97bd1678dfafc b/regress/corpus/bbf23d7a922eb1af713698b5d0a97bd1678dfafc
new file mode 100644
index 0000000..d493a10
Binary files /dev/null and b/regress/corpus/bbf23d7a922eb1af713698b5d0a97bd1678dfafc differ
diff --git a/regress/corpus/bc12b6d759a2d54493ad432b28d4b01827676cd3 b/regress/corpus/bc12b6d759a2d54493ad432b28d4b01827676cd3
new file mode 100644
index 0000000..f81f569
Binary files /dev/null and b/regress/corpus/bc12b6d759a2d54493ad432b28d4b01827676cd3 differ
diff --git a/regress/corpus/bcb4e4faf0f79cef1426dba462fd6847f2c69d44 b/regress/corpus/bcb4e4faf0f79cef1426dba462fd6847f2c69d44
new file mode 100644
index 0000000..bdb7ee3
Binary files /dev/null and b/regress/corpus/bcb4e4faf0f79cef1426dba462fd6847f2c69d44 differ
diff --git a/regress/corpus/bce78666f7faca7fd1b6482b256441d827d23db1 b/regress/corpus/bce78666f7faca7fd1b6482b256441d827d23db1
new file mode 100644
index 0000000..737e91e
Binary files /dev/null and b/regress/corpus/bce78666f7faca7fd1b6482b256441d827d23db1 differ
diff --git a/regress/corpus/bcee87d1ead578589a050bd1d70720ef0895b36d b/regress/corpus/bcee87d1ead578589a050bd1d70720ef0895b36d
new file mode 100644
index 0000000..55e86d0
Binary files /dev/null and b/regress/corpus/bcee87d1ead578589a050bd1d70720ef0895b36d differ
diff --git a/regress/corpus/bd6a68f75c0a87743da59839837df210ff993ec3 b/regress/corpus/bd6a68f75c0a87743da59839837df210ff993ec3
new file mode 100644
index 0000000..47b34a2
Binary files /dev/null and b/regress/corpus/bd6a68f75c0a87743da59839837df210ff993ec3 differ
diff --git a/regress/corpus/bdbd4468da9c8866455530d83bba8afbb170648c b/regress/corpus/bdbd4468da9c8866455530d83bba8afbb170648c
new file mode 100644
index 0000000..59722b7
Binary files /dev/null and b/regress/corpus/bdbd4468da9c8866455530d83bba8afbb170648c differ
diff --git a/regress/corpus/be2814f401045b146eaeda95c4ef217cd1efd7fc b/regress/corpus/be2814f401045b146eaeda95c4ef217cd1efd7fc
new file mode 100644
index 0000000..7cd9f5a
Binary files /dev/null and b/regress/corpus/be2814f401045b146eaeda95c4ef217cd1efd7fc differ
diff --git a/regress/corpus/be6aacbb35f624d515ad7dba0d243be7f63a6cb5 b/regress/corpus/be6aacbb35f624d515ad7dba0d243be7f63a6cb5
new file mode 100644
index 0000000..fb8b5d1
Binary files /dev/null and b/regress/corpus/be6aacbb35f624d515ad7dba0d243be7f63a6cb5 differ
diff --git a/regress/corpus/be9d33c759830203b9895cf901edf38941ce8362 b/regress/corpus/be9d33c759830203b9895cf901edf38941ce8362
new file mode 100644
index 0000000..8c1962c
Binary files /dev/null and b/regress/corpus/be9d33c759830203b9895cf901edf38941ce8362 differ
diff --git a/regress/corpus/beee1902079c7a6fdc9b573f3e113f31557a2f10 b/regress/corpus/beee1902079c7a6fdc9b573f3e113f31557a2f10
new file mode 100644
index 0000000..e92b9ad
Binary files /dev/null and b/regress/corpus/beee1902079c7a6fdc9b573f3e113f31557a2f10 differ
diff --git a/regress/corpus/bef8d337015a462023338c4fbb0307b729c93475 b/regress/corpus/bef8d337015a462023338c4fbb0307b729c93475
new file mode 100644
index 0000000..d7a25ac
Binary files /dev/null and b/regress/corpus/bef8d337015a462023338c4fbb0307b729c93475 differ
diff --git a/regress/corpus/befc81e605a9ffc8049f3d459e8c0c434a9d6e8c b/regress/corpus/befc81e605a9ffc8049f3d459e8c0c434a9d6e8c
new file mode 100644
index 0000000..df236fc
Binary files /dev/null and b/regress/corpus/befc81e605a9ffc8049f3d459e8c0c434a9d6e8c differ
diff --git a/regress/corpus/bf42bfa5f54f6e7da74e035d1bb220476d62b716 b/regress/corpus/bf42bfa5f54f6e7da74e035d1bb220476d62b716
new file mode 100644
index 0000000..11c8a35
Binary files /dev/null and b/regress/corpus/bf42bfa5f54f6e7da74e035d1bb220476d62b716 differ
diff --git a/regress/corpus/bf45059db459aeb3d851961de1b0ba5fdc5a963c b/regress/corpus/bf45059db459aeb3d851961de1b0ba5fdc5a963c
new file mode 100644
index 0000000..a2033d1
Binary files /dev/null and b/regress/corpus/bf45059db459aeb3d851961de1b0ba5fdc5a963c differ
diff --git a/regress/corpus/bf55a41f881bae8c6b5274c6b63bfa9054c00cb5 b/regress/corpus/bf55a41f881bae8c6b5274c6b63bfa9054c00cb5
new file mode 100644
index 0000000..09ef6df
Binary files /dev/null and b/regress/corpus/bf55a41f881bae8c6b5274c6b63bfa9054c00cb5 differ
diff --git a/regress/corpus/c020dd9e6add4cd8d7a927bd3db3e3d2156cb62b b/regress/corpus/c020dd9e6add4cd8d7a927bd3db3e3d2156cb62b
new file mode 100644
index 0000000..e9a8735
Binary files /dev/null and b/regress/corpus/c020dd9e6add4cd8d7a927bd3db3e3d2156cb62b differ
diff --git a/regress/corpus/c0460f95ede5eb9da2b5c006c32b0dfb86efac9f b/regress/corpus/c0460f95ede5eb9da2b5c006c32b0dfb86efac9f
new file mode 100644
index 0000000..fcd026e
Binary files /dev/null and b/regress/corpus/c0460f95ede5eb9da2b5c006c32b0dfb86efac9f differ
diff --git a/regress/corpus/c09edcd7dc248fbb16b9647a12b1c45ed26da487 b/regress/corpus/c09edcd7dc248fbb16b9647a12b1c45ed26da487
new file mode 100644
index 0000000..733622c
Binary files /dev/null and b/regress/corpus/c09edcd7dc248fbb16b9647a12b1c45ed26da487 differ
diff --git a/regress/corpus/c16733744e1e280006ad5611998a8de5d14732ef b/regress/corpus/c16733744e1e280006ad5611998a8de5d14732ef
new file mode 100644
index 0000000..388f37a
Binary files /dev/null and b/regress/corpus/c16733744e1e280006ad5611998a8de5d14732ef differ
diff --git a/regress/corpus/c1a9516887256b4e5189688352a90b82fb13f56f b/regress/corpus/c1a9516887256b4e5189688352a90b82fb13f56f
new file mode 100644
index 0000000..1d1559c
Binary files /dev/null and b/regress/corpus/c1a9516887256b4e5189688352a90b82fb13f56f differ
diff --git a/regress/corpus/c1b7e1142094815a857b6eb7e33d67c2a35c0ea1 b/regress/corpus/c1b7e1142094815a857b6eb7e33d67c2a35c0ea1
new file mode 100644
index 0000000..c2ee672
Binary files /dev/null and b/regress/corpus/c1b7e1142094815a857b6eb7e33d67c2a35c0ea1 differ
diff --git a/regress/corpus/c20f8fbba5bac220b3084f9c5b0d66e4fd5d6dd1 b/regress/corpus/c20f8fbba5bac220b3084f9c5b0d66e4fd5d6dd1
new file mode 100644
index 0000000..ba174f5
Binary files /dev/null and b/regress/corpus/c20f8fbba5bac220b3084f9c5b0d66e4fd5d6dd1 differ
diff --git a/regress/corpus/c263799d4a950306429793b5f147561e0492bd1d b/regress/corpus/c263799d4a950306429793b5f147561e0492bd1d
new file mode 100644
index 0000000..bec63c5
--- /dev/null
+++ b/regress/corpus/c263799d4a950306429793b5f147561e0492bd1d
@@ -0,0 +1 @@
+@ÿÿ
\ No newline at end of file
diff --git a/regress/corpus/c2e009fb4ba0476584dc90a9ab7d3921b706bf0d b/regress/corpus/c2e009fb4ba0476584dc90a9ab7d3921b706bf0d
new file mode 100644
index 0000000..aa08bdd
Binary files /dev/null and b/regress/corpus/c2e009fb4ba0476584dc90a9ab7d3921b706bf0d differ
diff --git a/regress/corpus/c2f175f6432b7ce470a316d18c370705d3b828ba b/regress/corpus/c2f175f6432b7ce470a316d18c370705d3b828ba
new file mode 100644
index 0000000..d59f394
Binary files /dev/null and b/regress/corpus/c2f175f6432b7ce470a316d18c370705d3b828ba differ
diff --git a/regress/corpus/c3010d09174a3c3b96be53994dde3f2655747438 b/regress/corpus/c3010d09174a3c3b96be53994dde3f2655747438
new file mode 100644
index 0000000..86da56b
--- /dev/null
+++ b/regress/corpus/c3010d09174a3c3b96be53994dde3f2655747438
@@ -0,0 +1 @@
+8ý
\ No newline at end of file
diff --git a/regress/corpus/c336f4b6a44453b74210504eb4b2ad20723c83ee b/regress/corpus/c336f4b6a44453b74210504eb4b2ad20723c83ee
new file mode 100644
index 0000000..2e3bbd0
Binary files /dev/null and b/regress/corpus/c336f4b6a44453b74210504eb4b2ad20723c83ee differ
diff --git a/regress/corpus/c35bb14ea7df1ecfb0a8c5de65aac4ab608de38e b/regress/corpus/c35bb14ea7df1ecfb0a8c5de65aac4ab608de38e
new file mode 100644
index 0000000..0d7c207
Binary files /dev/null and b/regress/corpus/c35bb14ea7df1ecfb0a8c5de65aac4ab608de38e differ
diff --git a/regress/corpus/c3b494296cba5f6a9f9e76f093fad0cc5bc65804 b/regress/corpus/c3b494296cba5f6a9f9e76f093fad0cc5bc65804
new file mode 100644
index 0000000..5cce206
Binary files /dev/null and b/regress/corpus/c3b494296cba5f6a9f9e76f093fad0cc5bc65804 differ
diff --git a/regress/corpus/c40f784835c714d59e769b094c8b3055e0487299 b/regress/corpus/c40f784835c714d59e769b094c8b3055e0487299
new file mode 100644
index 0000000..0ecd08d
--- /dev/null
+++ b/regress/corpus/c40f784835c714d59e769b094c8b3055e0487299
@@ -0,0 +1 @@
+ž
\ No newline at end of file
diff --git a/regress/corpus/c49b95d2d30f747115ca665727c53b4e20eb00b4 b/regress/corpus/c49b95d2d30f747115ca665727c53b4e20eb00b4
new file mode 100644
index 0000000..ab67e77
Binary files /dev/null and b/regress/corpus/c49b95d2d30f747115ca665727c53b4e20eb00b4 differ
diff --git a/regress/corpus/c4d559de6a81ad20f83f1649fb1d28c360a34c2d b/regress/corpus/c4d559de6a81ad20f83f1649fb1d28c360a34c2d
new file mode 100644
index 0000000..053b135
Binary files /dev/null and b/regress/corpus/c4d559de6a81ad20f83f1649fb1d28c360a34c2d differ
diff --git a/regress/corpus/c52864c5210cc8df5341c731fbf46f8d38c0922f b/regress/corpus/c52864c5210cc8df5341c731fbf46f8d38c0922f
new file mode 100644
index 0000000..e288230
Binary files /dev/null and b/regress/corpus/c52864c5210cc8df5341c731fbf46f8d38c0922f differ
diff --git a/regress/corpus/c56b2e8d64ab8c09551529a8bbece474d200f459 b/regress/corpus/c56b2e8d64ab8c09551529a8bbece474d200f459
new file mode 100644
index 0000000..ae98294
Binary files /dev/null and b/regress/corpus/c56b2e8d64ab8c09551529a8bbece474d200f459 differ
diff --git a/regress/corpus/c5c671484563285fc41967f952bf607fd38212cb b/regress/corpus/c5c671484563285fc41967f952bf607fd38212cb
new file mode 100644
index 0000000..84d35dd
Binary files /dev/null and b/regress/corpus/c5c671484563285fc41967f952bf607fd38212cb differ
diff --git a/regress/corpus/c617c1f9be12a6be9181d8251e606e86e3b6f18d b/regress/corpus/c617c1f9be12a6be9181d8251e606e86e3b6f18d
new file mode 100644
index 0000000..9e45bb6
Binary files /dev/null and b/regress/corpus/c617c1f9be12a6be9181d8251e606e86e3b6f18d differ
diff --git a/regress/corpus/c6b9f4180cdcbbd2a65490f4868a2fa9299f4a5f b/regress/corpus/c6b9f4180cdcbbd2a65490f4868a2fa9299f4a5f
new file mode 100644
index 0000000..f91dbf2
Binary files /dev/null and b/regress/corpus/c6b9f4180cdcbbd2a65490f4868a2fa9299f4a5f differ
diff --git a/regress/corpus/c708564a23cbd68ad4176bee93add3b13946f5b4 b/regress/corpus/c708564a23cbd68ad4176bee93add3b13946f5b4
new file mode 100644
index 0000000..8986e6f
Binary files /dev/null and b/regress/corpus/c708564a23cbd68ad4176bee93add3b13946f5b4 differ
diff --git a/regress/corpus/c7aa7623cea270dfbd0734a1b15174606d659ae6 b/regress/corpus/c7aa7623cea270dfbd0734a1b15174606d659ae6
new file mode 100644
index 0000000..7adfc20
Binary files /dev/null and b/regress/corpus/c7aa7623cea270dfbd0734a1b15174606d659ae6 differ
diff --git a/regress/corpus/c7ac83f2a9733dbb6aa16a80a806a16fc57babc1 b/regress/corpus/c7ac83f2a9733dbb6aa16a80a806a16fc57babc1
new file mode 100644
index 0000000..2375d63
Binary files /dev/null and b/regress/corpus/c7ac83f2a9733dbb6aa16a80a806a16fc57babc1 differ
diff --git a/regress/corpus/c7bc773a4febfc9da9949b48dfa9d36bb88ca993 b/regress/corpus/c7bc773a4febfc9da9949b48dfa9d36bb88ca993
new file mode 100644
index 0000000..4e6167e
Binary files /dev/null and b/regress/corpus/c7bc773a4febfc9da9949b48dfa9d36bb88ca993 differ
diff --git a/regress/corpus/c7e5af1acdf19e3f8326f8c7fe7ee346e5370068 b/regress/corpus/c7e5af1acdf19e3f8326f8c7fe7ee346e5370068
new file mode 100644
index 0000000..11c58ba
Binary files /dev/null and b/regress/corpus/c7e5af1acdf19e3f8326f8c7fe7ee346e5370068 differ
diff --git a/regress/corpus/c80099666cf976f3b92265aba9542778ccfe3ef5 b/regress/corpus/c80099666cf976f3b92265aba9542778ccfe3ef5
new file mode 100644
index 0000000..724c9bf
--- /dev/null
+++ b/regress/corpus/c80099666cf976f3b92265aba9542778ccfe3ef5
@@ -0,0 +1 @@
+/þùŸ ˆsqþ
\ No newline at end of file
diff --git a/regress/corpus/c812202b413fb8486cf41dd946111f7e8dc43269 b/regress/corpus/c812202b413fb8486cf41dd946111f7e8dc43269
new file mode 100644
index 0000000..3479a71
Binary files /dev/null and b/regress/corpus/c812202b413fb8486cf41dd946111f7e8dc43269 differ
diff --git a/regress/corpus/c83730cbc9b078dba78a358e2af1fd359978187b b/regress/corpus/c83730cbc9b078dba78a358e2af1fd359978187b
new file mode 100644
index 0000000..ed8e198
Binary files /dev/null and b/regress/corpus/c83730cbc9b078dba78a358e2af1fd359978187b differ
diff --git a/regress/corpus/c8525a2f769bf2d815109db14a3ca924c8632107 b/regress/corpus/c8525a2f769bf2d815109db14a3ca924c8632107
new file mode 100644
index 0000000..abe2fda
Binary files /dev/null and b/regress/corpus/c8525a2f769bf2d815109db14a3ca924c8632107 differ
diff --git a/regress/corpus/c8540ad5d178485dfcd598178bfc27f53ee669ad b/regress/corpus/c8540ad5d178485dfcd598178bfc27f53ee669ad
new file mode 100644
index 0000000..2d3c81b
Binary files /dev/null and b/regress/corpus/c8540ad5d178485dfcd598178bfc27f53ee669ad differ
diff --git a/regress/corpus/c8dc87883b735ad83b1194e72711f49b77307536 b/regress/corpus/c8dc87883b735ad83b1194e72711f49b77307536
new file mode 100644
index 0000000..390e5ed
Binary files /dev/null and b/regress/corpus/c8dc87883b735ad83b1194e72711f49b77307536 differ
diff --git a/regress/corpus/c9071dfd96736ee35661468f780322be27c58dae b/regress/corpus/c9071dfd96736ee35661468f780322be27c58dae
new file mode 100644
index 0000000..176c86d
Binary files /dev/null and b/regress/corpus/c9071dfd96736ee35661468f780322be27c58dae differ
diff --git a/regress/corpus/c9b59c50fb3d5d681ba0d738b03f002ad735086d b/regress/corpus/c9b59c50fb3d5d681ba0d738b03f002ad735086d
new file mode 100644
index 0000000..4fb12d4
--- /dev/null
+++ b/regress/corpus/c9b59c50fb3d5d681ba0d738b03f002ad735086d
@@ -0,0 +1 @@
+¹¹¹ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
\ No newline at end of file
diff --git a/regress/corpus/c9c4e1e2720eb1d1c7584a3feacdfc4e95d9a6a2 b/regress/corpus/c9c4e1e2720eb1d1c7584a3feacdfc4e95d9a6a2
new file mode 100644
index 0000000..d0b367c
Binary files /dev/null and b/regress/corpus/c9c4e1e2720eb1d1c7584a3feacdfc4e95d9a6a2 differ
diff --git a/regress/corpus/ca01ce0515aba88d5e07d3bfb070c735cae2c702 b/regress/corpus/ca01ce0515aba88d5e07d3bfb070c735cae2c702
new file mode 100644
index 0000000..455d385
Binary files /dev/null and b/regress/corpus/ca01ce0515aba88d5e07d3bfb070c735cae2c702 differ
diff --git a/regress/corpus/ca3d93adc2bfdb1da7a85baec799262e8b501089 b/regress/corpus/ca3d93adc2bfdb1da7a85baec799262e8b501089
new file mode 100644
index 0000000..4521d5e
Binary files /dev/null and b/regress/corpus/ca3d93adc2bfdb1da7a85baec799262e8b501089 differ
diff --git a/regress/corpus/cae3176c911643b6bf5183c3273c7852f6dac051 b/regress/corpus/cae3176c911643b6bf5183c3273c7852f6dac051
new file mode 100644
index 0000000..008f385
Binary files /dev/null and b/regress/corpus/cae3176c911643b6bf5183c3273c7852f6dac051 differ
diff --git a/regress/corpus/caf2a4e67e32494c4e55048ad2bc27862b224c22 b/regress/corpus/caf2a4e67e32494c4e55048ad2bc27862b224c22
new file mode 100644
index 0000000..a96b303
Binary files /dev/null and b/regress/corpus/caf2a4e67e32494c4e55048ad2bc27862b224c22 differ
diff --git a/regress/corpus/cb8af43d4654eef3988a49a225e5e176a7198a9f b/regress/corpus/cb8af43d4654eef3988a49a225e5e176a7198a9f
new file mode 100644
index 0000000..3fd2534
Binary files /dev/null and b/regress/corpus/cb8af43d4654eef3988a49a225e5e176a7198a9f differ
diff --git a/regress/corpus/cbd82c6cc59a05c86f271d83871c788433489d6f b/regress/corpus/cbd82c6cc59a05c86f271d83871c788433489d6f
new file mode 100644
index 0000000..836a934
--- /dev/null
+++ b/regress/corpus/cbd82c6cc59a05c86f271d83871c788433489d6f
@@ -0,0 +1 @@
+

ÿÿÿÿÿ¹ÿÿÿÿÿÿ¹ÿÿÿ
\ No newline at end of file
diff --git a/regress/corpus/cbe0d65339f01436a83279a39a38039caece4f75 b/regress/corpus/cbe0d65339f01436a83279a39a38039caece4f75
new file mode 100644
index 0000000..1ddac98
Binary files /dev/null and b/regress/corpus/cbe0d65339f01436a83279a39a38039caece4f75 differ
diff --git a/regress/corpus/cbe6dc1dfe0bd2d1e405449d8ba41755956309d0 b/regress/corpus/cbe6dc1dfe0bd2d1e405449d8ba41755956309d0
new file mode 100644
index 0000000..813f4e7
Binary files /dev/null and b/regress/corpus/cbe6dc1dfe0bd2d1e405449d8ba41755956309d0 differ
diff --git a/regress/corpus/ccd34d9379114084d19d35d0a9cf9f7932f62194 b/regress/corpus/ccd34d9379114084d19d35d0a9cf9f7932f62194
new file mode 100644
index 0000000..9d1d61e
Binary files /dev/null and b/regress/corpus/ccd34d9379114084d19d35d0a9cf9f7932f62194 differ
diff --git a/regress/corpus/ccd3ac74ef87290a2e75e0c00d106bd3d4c28862 b/regress/corpus/ccd3ac74ef87290a2e75e0c00d106bd3d4c28862
new file mode 100644
index 0000000..579400b
Binary files /dev/null and b/regress/corpus/ccd3ac74ef87290a2e75e0c00d106bd3d4c28862 differ
diff --git a/regress/corpus/cd17446c3c58c27dd19280aec18232b808ec0f16 b/regress/corpus/cd17446c3c58c27dd19280aec18232b808ec0f16
new file mode 100644
index 0000000..821e920
Binary files /dev/null and b/regress/corpus/cd17446c3c58c27dd19280aec18232b808ec0f16 differ
diff --git a/regress/corpus/cd366177a6746172025e0466a626159e818d9256 b/regress/corpus/cd366177a6746172025e0466a626159e818d9256
new file mode 100644
index 0000000..9fb512a
Binary files /dev/null and b/regress/corpus/cd366177a6746172025e0466a626159e818d9256 differ
diff --git a/regress/corpus/cd8f547cae0627fbd063d09009da2d742de93097 b/regress/corpus/cd8f547cae0627fbd063d09009da2d742de93097
new file mode 100644
index 0000000..9719f35
--- /dev/null
+++ b/regress/corpus/cd8f547cae0627fbd063d09009da2d742de93097
@@ -0,0 +1 @@
+88888888888È8888888888888888888888888È888888888888888888888888888888888888888888888888888888
ôÿÿœ�MMM²²²
\ No newline at end of file
diff --git a/regress/corpus/cda35f636a7e30dacacb43664acfb780392fcfaf b/regress/corpus/cda35f636a7e30dacacb43664acfb780392fcfaf
new file mode 100644
index 0000000..c34f649
--- /dev/null
+++ b/regress/corpus/cda35f636a7e30dacacb43664acfb780392fcfaf
@@ -0,0 +1 @@
+÷ÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉ	¹
\ No newline at end of file
diff --git a/regress/corpus/cdaf28ed078bb1ae708c4067893e3bf7189232c7 b/regress/corpus/cdaf28ed078bb1ae708c4067893e3bf7189232c7
new file mode 100644
index 0000000..0f5856b
Binary files /dev/null and b/regress/corpus/cdaf28ed078bb1ae708c4067893e3bf7189232c7 differ
diff --git a/regress/corpus/cdfc94416f474d8e5a2c36cd4c09e38d47fd30fc b/regress/corpus/cdfc94416f474d8e5a2c36cd4c09e38d47fd30fc
new file mode 100644
index 0000000..3b94979
--- /dev/null
+++ b/regress/corpus/cdfc94416f474d8e5a2c36cd4c09e38d47fd30fc
@@ -0,0 +1 @@
+‹‹
\ No newline at end of file
diff --git a/regress/corpus/ce029ff4a578276d475748d8b2366393cabf5d69 b/regress/corpus/ce029ff4a578276d475748d8b2366393cabf5d69
new file mode 100644
index 0000000..3299596
Binary files /dev/null and b/regress/corpus/ce029ff4a578276d475748d8b2366393cabf5d69 differ
diff --git a/regress/corpus/cf1e0565eb5daf5f6ad3cdf195a0f9c802bc337c b/regress/corpus/cf1e0565eb5daf5f6ad3cdf195a0f9c802bc337c
new file mode 100644
index 0000000..4b15c11
Binary files /dev/null and b/regress/corpus/cf1e0565eb5daf5f6ad3cdf195a0f9c802bc337c differ
diff --git a/regress/corpus/cf762468c981ec4c187555edbde9eaca8c6813cd b/regress/corpus/cf762468c981ec4c187555edbde9eaca8c6813cd
new file mode 100644
index 0000000..d08b361
Binary files /dev/null and b/regress/corpus/cf762468c981ec4c187555edbde9eaca8c6813cd differ
diff --git a/regress/corpus/cfc07908070d2bbd3c5fcd06852d5698686e30d2 b/regress/corpus/cfc07908070d2bbd3c5fcd06852d5698686e30d2
new file mode 100644
index 0000000..c41abd3
Binary files /dev/null and b/regress/corpus/cfc07908070d2bbd3c5fcd06852d5698686e30d2 differ
diff --git a/regress/corpus/crash-1ffe2d52cb820525e38d1605a0a359eebdb398e7 b/regress/corpus/crash-1ffe2d52cb820525e38d1605a0a359eebdb398e7
new file mode 100644
index 0000000..7f212f6
Binary files /dev/null and b/regress/corpus/crash-1ffe2d52cb820525e38d1605a0a359eebdb398e7 differ
diff --git a/regress/corpus/crash-6a5c9ebb65a8aa4cb57aeccfb19b4d892093e418 b/regress/corpus/crash-6a5c9ebb65a8aa4cb57aeccfb19b4d892093e418
new file mode 100644
index 0000000..5321e94
Binary files /dev/null and b/regress/corpus/crash-6a5c9ebb65a8aa4cb57aeccfb19b4d892093e418 differ
diff --git a/regress/corpus/crash-f68d01ae9b54206705c49ddf24eedb6177b01b8c b/regress/corpus/crash-f68d01ae9b54206705c49ddf24eedb6177b01b8c
new file mode 100644
index 0000000..a5ae2f5
Binary files /dev/null and b/regress/corpus/crash-f68d01ae9b54206705c49ddf24eedb6177b01b8c differ
diff --git a/regress/corpus/d04c6b25a1bf59ddc47f36009b6867b158daa430 b/regress/corpus/d04c6b25a1bf59ddc47f36009b6867b158daa430
new file mode 100644
index 0000000..0645433
Binary files /dev/null and b/regress/corpus/d04c6b25a1bf59ddc47f36009b6867b158daa430 differ
diff --git a/regress/corpus/d04f586e1d2e92ed9dff2690236bf76282e0442b b/regress/corpus/d04f586e1d2e92ed9dff2690236bf76282e0442b
new file mode 100644
index 0000000..2477901
Binary files /dev/null and b/regress/corpus/d04f586e1d2e92ed9dff2690236bf76282e0442b differ
diff --git a/regress/corpus/d05418c9cae79581541ab9b3352c06606b585dae b/regress/corpus/d05418c9cae79581541ab9b3352c06606b585dae
new file mode 100644
index 0000000..ceb67ec
Binary files /dev/null and b/regress/corpus/d05418c9cae79581541ab9b3352c06606b585dae differ
diff --git a/regress/corpus/d05ef293a52f6ab11cebe584ef16714c68551486 b/regress/corpus/d05ef293a52f6ab11cebe584ef16714c68551486
new file mode 100644
index 0000000..b6b1958
Binary files /dev/null and b/regress/corpus/d05ef293a52f6ab11cebe584ef16714c68551486 differ
diff --git a/regress/corpus/d09d1d4eda0c773342e4beae5429837be0f585cc b/regress/corpus/d09d1d4eda0c773342e4beae5429837be0f585cc
new file mode 100644
index 0000000..294eb33
Binary files /dev/null and b/regress/corpus/d09d1d4eda0c773342e4beae5429837be0f585cc differ
diff --git a/regress/corpus/d0e75c385f166feff592fc6e37d7f9f8b862e482 b/regress/corpus/d0e75c385f166feff592fc6e37d7f9f8b862e482
new file mode 100644
index 0000000..ea3725a
Binary files /dev/null and b/regress/corpus/d0e75c385f166feff592fc6e37d7f9f8b862e482 differ
diff --git a/regress/corpus/d11a5ebb0863dd669610285ddf34b758c59e5178 b/regress/corpus/d11a5ebb0863dd669610285ddf34b758c59e5178
new file mode 100644
index 0000000..e18f63d
Binary files /dev/null and b/regress/corpus/d11a5ebb0863dd669610285ddf34b758c59e5178 differ
diff --git a/regress/corpus/d11dbb1c679510cdb91dd9cb890932398296ced1 b/regress/corpus/d11dbb1c679510cdb91dd9cb890932398296ced1
new file mode 100644
index 0000000..af5315d
Binary files /dev/null and b/regress/corpus/d11dbb1c679510cdb91dd9cb890932398296ced1 differ
diff --git a/regress/corpus/d146a1173e1dde8a09532320491271a740e31c1f b/regress/corpus/d146a1173e1dde8a09532320491271a740e31c1f
new file mode 100644
index 0000000..75522b9
Binary files /dev/null and b/regress/corpus/d146a1173e1dde8a09532320491271a740e31c1f differ
diff --git a/regress/corpus/d1c130045f8f4c03f73e8f076d2b5cd3495c44f4 b/regress/corpus/d1c130045f8f4c03f73e8f076d2b5cd3495c44f4
new file mode 100644
index 0000000..d655035
Binary files /dev/null and b/regress/corpus/d1c130045f8f4c03f73e8f076d2b5cd3495c44f4 differ
diff --git a/regress/corpus/d1cc254019dcc54e6b32bdacabf708589daff037 b/regress/corpus/d1cc254019dcc54e6b32bdacabf708589daff037
new file mode 100644
index 0000000..7f13152
Binary files /dev/null and b/regress/corpus/d1cc254019dcc54e6b32bdacabf708589daff037 differ
diff --git a/regress/corpus/d2044f8ac75c10c47f66fcccdafaa76878a78774 b/regress/corpus/d2044f8ac75c10c47f66fcccdafaa76878a78774
new file mode 100644
index 0000000..194b346
Binary files /dev/null and b/regress/corpus/d2044f8ac75c10c47f66fcccdafaa76878a78774 differ
diff --git a/regress/corpus/d257712d83aaf0108ada1d496134724ef46270ac b/regress/corpus/d257712d83aaf0108ada1d496134724ef46270ac
new file mode 100644
index 0000000..8a31197
Binary files /dev/null and b/regress/corpus/d257712d83aaf0108ada1d496134724ef46270ac differ
diff --git a/regress/corpus/d2de34a68d9d3e51d89d8df7b7c73493778249bb b/regress/corpus/d2de34a68d9d3e51d89d8df7b7c73493778249bb
new file mode 100644
index 0000000..4da7ff7
Binary files /dev/null and b/regress/corpus/d2de34a68d9d3e51d89d8df7b7c73493778249bb differ
diff --git a/regress/corpus/d33c7466850a3d82b93192fd5bd444a7fd5ad8e1 b/regress/corpus/d33c7466850a3d82b93192fd5bd444a7fd5ad8e1
new file mode 100644
index 0000000..b219ccc
Binary files /dev/null and b/regress/corpus/d33c7466850a3d82b93192fd5bd444a7fd5ad8e1 differ
diff --git a/regress/corpus/d35168db29584eb66f8f31e1dabe95ab382ae2a5 b/regress/corpus/d35168db29584eb66f8f31e1dabe95ab382ae2a5
new file mode 100644
index 0000000..9811ddf
Binary files /dev/null and b/regress/corpus/d35168db29584eb66f8f31e1dabe95ab382ae2a5 differ
diff --git a/regress/corpus/d35a89dfaf68742d25497d59e195ed3596d21d66 b/regress/corpus/d35a89dfaf68742d25497d59e195ed3596d21d66
new file mode 100644
index 0000000..885f0ba
Binary files /dev/null and b/regress/corpus/d35a89dfaf68742d25497d59e195ed3596d21d66 differ
diff --git a/regress/corpus/d3769b9479a21d0fd6b70cbfaf85781a1bf86f57 b/regress/corpus/d3769b9479a21d0fd6b70cbfaf85781a1bf86f57
new file mode 100644
index 0000000..97701c0
Binary files /dev/null and b/regress/corpus/d3769b9479a21d0fd6b70cbfaf85781a1bf86f57 differ
diff --git a/regress/corpus/d38536ab6ac0f35180a9688772af0a6429f6eeb8 b/regress/corpus/d38536ab6ac0f35180a9688772af0a6429f6eeb8
new file mode 100644
index 0000000..d851ba1
--- /dev/null
+++ b/regress/corpus/d38536ab6ac0f35180a9688772af0a6429f6eeb8
@@ -0,0 +1 @@
+¹¹
\ No newline at end of file
diff --git a/regress/corpus/d3dd97df2493588272c79e1c413fdfddfc68bad2 b/regress/corpus/d3dd97df2493588272c79e1c413fdfddfc68bad2
new file mode 100644
index 0000000..6503da8
Binary files /dev/null and b/regress/corpus/d3dd97df2493588272c79e1c413fdfddfc68bad2 differ
diff --git a/regress/corpus/d41c4b56c9666bbf3e2e9b5b65ec2543d9d05683 b/regress/corpus/d41c4b56c9666bbf3e2e9b5b65ec2543d9d05683
new file mode 100644
index 0000000..d76e705
Binary files /dev/null and b/regress/corpus/d41c4b56c9666bbf3e2e9b5b65ec2543d9d05683 differ
diff --git a/regress/corpus/d42f58863612722583a1bc10c257fb76f50951a9 b/regress/corpus/d42f58863612722583a1bc10c257fb76f50951a9
new file mode 100644
index 0000000..aa33677
Binary files /dev/null and b/regress/corpus/d42f58863612722583a1bc10c257fb76f50951a9 differ
diff --git a/regress/corpus/d461a444811cd33ebbb1fe415a5e2f71de54526e b/regress/corpus/d461a444811cd33ebbb1fe415a5e2f71de54526e
new file mode 100644
index 0000000..cce04d7
Binary files /dev/null and b/regress/corpus/d461a444811cd33ebbb1fe415a5e2f71de54526e differ
diff --git a/regress/corpus/d47da26c514238311232be339862e7b762e2ef6c b/regress/corpus/d47da26c514238311232be339862e7b762e2ef6c
new file mode 100644
index 0000000..36bae91
Binary files /dev/null and b/regress/corpus/d47da26c514238311232be339862e7b762e2ef6c differ
diff --git a/regress/corpus/d4e9ddff2b8b4c818291d06eb761dbef03d87eca b/regress/corpus/d4e9ddff2b8b4c818291d06eb761dbef03d87eca
new file mode 100644
index 0000000..2217b0d
Binary files /dev/null and b/regress/corpus/d4e9ddff2b8b4c818291d06eb761dbef03d87eca differ
diff --git a/regress/corpus/d50c96a92a0196e3aeaf569399006b407d76b971 b/regress/corpus/d50c96a92a0196e3aeaf569399006b407d76b971
new file mode 100644
index 0000000..53ba5a6
--- /dev/null
+++ b/regress/corpus/d50c96a92a0196e3aeaf569399006b407d76b971
@@ -0,0 +1 @@
+÷ÉÉÉÉÉɦ¦¦¦¦¦¦¦¦ÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉɹ
\ No newline at end of file
diff --git a/regress/corpus/d54cbf155e544a94bcde03a5c67631473be5dafc b/regress/corpus/d54cbf155e544a94bcde03a5c67631473be5dafc
new file mode 100644
index 0000000..43098ad
Binary files /dev/null and b/regress/corpus/d54cbf155e544a94bcde03a5c67631473be5dafc differ
diff --git a/regress/corpus/d5865c033bd6a5230f8917bc06f6f36e7cdc6e7a b/regress/corpus/d5865c033bd6a5230f8917bc06f6f36e7cdc6e7a
new file mode 100644
index 0000000..0a77fbb
Binary files /dev/null and b/regress/corpus/d5865c033bd6a5230f8917bc06f6f36e7cdc6e7a differ
diff --git a/regress/corpus/d5b70b54b05bd7555c73c309c6bec22c87b01c05 b/regress/corpus/d5b70b54b05bd7555c73c309c6bec22c87b01c05
new file mode 100644
index 0000000..a4d120a
Binary files /dev/null and b/regress/corpus/d5b70b54b05bd7555c73c309c6bec22c87b01c05 differ
diff --git a/regress/corpus/d5b7c88da455a3d0842dffb27002e12ce8dbda55 b/regress/corpus/d5b7c88da455a3d0842dffb27002e12ce8dbda55
new file mode 100644
index 0000000..8eaa2e0
Binary files /dev/null and b/regress/corpus/d5b7c88da455a3d0842dffb27002e12ce8dbda55 differ
diff --git a/regress/corpus/d6642acdb15110b68db1de860d5117a9170de56b b/regress/corpus/d6642acdb15110b68db1de860d5117a9170de56b
new file mode 100644
index 0000000..cf4039c
Binary files /dev/null and b/regress/corpus/d6642acdb15110b68db1de860d5117a9170de56b differ
diff --git a/regress/corpus/d675c3511a7b95d813d9cbbd8596ad486c0237c4 b/regress/corpus/d675c3511a7b95d813d9cbbd8596ad486c0237c4
new file mode 100644
index 0000000..fef943f
Binary files /dev/null and b/regress/corpus/d675c3511a7b95d813d9cbbd8596ad486c0237c4 differ
diff --git a/regress/corpus/d6e06f62e966f8a35132164fecbfdc7c83dd79c6 b/regress/corpus/d6e06f62e966f8a35132164fecbfdc7c83dd79c6
new file mode 100644
index 0000000..f7f148d
Binary files /dev/null and b/regress/corpus/d6e06f62e966f8a35132164fecbfdc7c83dd79c6 differ
diff --git a/regress/corpus/d6f513e2eb15150d2fd9dfc92bfbb637e97e782d b/regress/corpus/d6f513e2eb15150d2fd9dfc92bfbb637e97e782d
new file mode 100644
index 0000000..c238256
Binary files /dev/null and b/regress/corpus/d6f513e2eb15150d2fd9dfc92bfbb637e97e782d differ
diff --git a/regress/corpus/d6fa1c19e2889b9364516cf0d738351c51da5303 b/regress/corpus/d6fa1c19e2889b9364516cf0d738351c51da5303
new file mode 100644
index 0000000..c1509e0
Binary files /dev/null and b/regress/corpus/d6fa1c19e2889b9364516cf0d738351c51da5303 differ
diff --git a/regress/corpus/d70d3aef8f86800a35e4c8f42e18c642f23abfe5 b/regress/corpus/d70d3aef8f86800a35e4c8f42e18c642f23abfe5
new file mode 100644
index 0000000..3b39944
Binary files /dev/null and b/regress/corpus/d70d3aef8f86800a35e4c8f42e18c642f23abfe5 differ
diff --git a/regress/corpus/d718b07360712cdcf49043e905b4b573f04b2347 b/regress/corpus/d718b07360712cdcf49043e905b4b573f04b2347
new file mode 100644
index 0000000..bb07220
Binary files /dev/null and b/regress/corpus/d718b07360712cdcf49043e905b4b573f04b2347 differ
diff --git a/regress/corpus/d7df0a5136000f430d5a3f43000118ef69d62515 b/regress/corpus/d7df0a5136000f430d5a3f43000118ef69d62515
new file mode 100644
index 0000000..15cfa0b
--- /dev/null
+++ b/regress/corpus/d7df0a5136000f430d5a3f43000118ef69d62515
@@ -0,0 +1 @@
+











+





ùùùùùùùùùùùùùÒÒÒÒùù














\ No newline at end of file
diff --git a/regress/corpus/d7e2a5ae312da1d607870815e239de5ccbdcf814 b/regress/corpus/d7e2a5ae312da1d607870815e239de5ccbdcf814
new file mode 100644
index 0000000..c2e6646
Binary files /dev/null and b/regress/corpus/d7e2a5ae312da1d607870815e239de5ccbdcf814 differ
diff --git a/regress/corpus/d7fb1bcbe7f3cb856ab66b38482ae83b3277cea6 b/regress/corpus/d7fb1bcbe7f3cb856ab66b38482ae83b3277cea6
new file mode 100644
index 0000000..ad6afa0
Binary files /dev/null and b/regress/corpus/d7fb1bcbe7f3cb856ab66b38482ae83b3277cea6 differ
diff --git a/regress/corpus/d8030d39888564cebd83b1f797b4a137ca0d9989 b/regress/corpus/d8030d39888564cebd83b1f797b4a137ca0d9989
new file mode 100644
index 0000000..1c762e7
Binary files /dev/null and b/regress/corpus/d8030d39888564cebd83b1f797b4a137ca0d9989 differ
diff --git a/regress/corpus/d83be4bad854f3e4db4beb641b9eb7a155faf712 b/regress/corpus/d83be4bad854f3e4db4beb641b9eb7a155faf712
new file mode 100644
index 0000000..ed6e704
Binary files /dev/null and b/regress/corpus/d83be4bad854f3e4db4beb641b9eb7a155faf712 differ
diff --git a/regress/corpus/d85b1ce66e7452294089387dfca4aec5e97988b7 b/regress/corpus/d85b1ce66e7452294089387dfca4aec5e97988b7
new file mode 100644
index 0000000..d180df2
Binary files /dev/null and b/regress/corpus/d85b1ce66e7452294089387dfca4aec5e97988b7 differ
diff --git a/regress/corpus/d86b31b47bb3698d43a7c48c8dd5293c4a62f660 b/regress/corpus/d86b31b47bb3698d43a7c48c8dd5293c4a62f660
new file mode 100644
index 0000000..0e2ad34
Binary files /dev/null and b/regress/corpus/d86b31b47bb3698d43a7c48c8dd5293c4a62f660 differ
diff --git a/regress/corpus/d8a4b257342e905f728e2a4137b312cab8120846 b/regress/corpus/d8a4b257342e905f728e2a4137b312cab8120846
new file mode 100644
index 0000000..7615cc2
Binary files /dev/null and b/regress/corpus/d8a4b257342e905f728e2a4137b312cab8120846 differ
diff --git a/regress/corpus/d8c8b4ef67e1fee0d46e9306eada71d2540dc4f4 b/regress/corpus/d8c8b4ef67e1fee0d46e9306eada71d2540dc4f4
new file mode 100644
index 0000000..075bc94
Binary files /dev/null and b/regress/corpus/d8c8b4ef67e1fee0d46e9306eada71d2540dc4f4 differ
diff --git a/regress/corpus/d8ec92d0811a8326318e0f5b3a6375fa0990a55c b/regress/corpus/d8ec92d0811a8326318e0f5b3a6375fa0990a55c
new file mode 100644
index 0000000..97c8c3c
Binary files /dev/null and b/regress/corpus/d8ec92d0811a8326318e0f5b3a6375fa0990a55c differ
diff --git a/regress/corpus/da5e42c960e5b8ec9edd28ca79d39fe94a159fef b/regress/corpus/da5e42c960e5b8ec9edd28ca79d39fe94a159fef
new file mode 100644
index 0000000..ca8a8f0
Binary files /dev/null and b/regress/corpus/da5e42c960e5b8ec9edd28ca79d39fe94a159fef differ
diff --git a/regress/corpus/da986d1b14926903ab8f2b877aa6867045cc35c4 b/regress/corpus/da986d1b14926903ab8f2b877aa6867045cc35c4
new file mode 100644
index 0000000..208a00e
--- /dev/null
+++ b/regress/corpus/da986d1b14926903ab8f2b877aa6867045cc35c4
@@ -0,0 +1 @@
+



ÿÿ

















™¿`¢
\ No newline at end of file
diff --git a/regress/corpus/dac9a07ce39fc291c2120e506280ad2f206eed8f b/regress/corpus/dac9a07ce39fc291c2120e506280ad2f206eed8f
new file mode 100644
index 0000000..0e83f19
Binary files /dev/null and b/regress/corpus/dac9a07ce39fc291c2120e506280ad2f206eed8f differ
diff --git a/regress/corpus/dad45a7cfadc44dfe9703a80236c3d339a60d520 b/regress/corpus/dad45a7cfadc44dfe9703a80236c3d339a60d520
new file mode 100644
index 0000000..317a586
Binary files /dev/null and b/regress/corpus/dad45a7cfadc44dfe9703a80236c3d339a60d520 differ
diff --git a/regress/corpus/dbc694587804e087833fcd2c339477298723bcf7 b/regress/corpus/dbc694587804e087833fcd2c339477298723bcf7
new file mode 100644
index 0000000..3e7f5af
Binary files /dev/null and b/regress/corpus/dbc694587804e087833fcd2c339477298723bcf7 differ
diff --git a/regress/corpus/dbdea4e5bf4aa45f6fabf59654a091897bfc51dc b/regress/corpus/dbdea4e5bf4aa45f6fabf59654a091897bfc51dc
new file mode 100644
index 0000000..9858756
Binary files /dev/null and b/regress/corpus/dbdea4e5bf4aa45f6fabf59654a091897bfc51dc differ
diff --git a/regress/corpus/dc0286cd1e5227d67b3976038313be9c3e3b656b b/regress/corpus/dc0286cd1e5227d67b3976038313be9c3e3b656b
new file mode 100644
index 0000000..83e0905
Binary files /dev/null and b/regress/corpus/dc0286cd1e5227d67b3976038313be9c3e3b656b differ
diff --git a/regress/corpus/dc260412a2c568625f5fb2ff652c20c7c8e0dd9f b/regress/corpus/dc260412a2c568625f5fb2ff652c20c7c8e0dd9f
new file mode 100644
index 0000000..e65b6dd
Binary files /dev/null and b/regress/corpus/dc260412a2c568625f5fb2ff652c20c7c8e0dd9f differ
diff --git a/regress/corpus/dcb0f7291dba05c966d56f9b59ef38510cb812e4 b/regress/corpus/dcb0f7291dba05c966d56f9b59ef38510cb812e4
new file mode 100644
index 0000000..782d885
Binary files /dev/null and b/regress/corpus/dcb0f7291dba05c966d56f9b59ef38510cb812e4 differ
diff --git a/regress/corpus/dd3f77506432cb506758e1f0bf7290ba2ca0c0e2 b/regress/corpus/dd3f77506432cb506758e1f0bf7290ba2ca0c0e2
new file mode 100644
index 0000000..61d0581
Binary files /dev/null and b/regress/corpus/dd3f77506432cb506758e1f0bf7290ba2ca0c0e2 differ
diff --git a/regress/corpus/dd4a88e95bec6954824343743c2223df844d8a5e b/regress/corpus/dd4a88e95bec6954824343743c2223df844d8a5e
new file mode 100644
index 0000000..7580f25
Binary files /dev/null and b/regress/corpus/dd4a88e95bec6954824343743c2223df844d8a5e differ
diff --git a/regress/corpus/dd76ad17bc40a3448a059e0d47c4219c3aefee00 b/regress/corpus/dd76ad17bc40a3448a059e0d47c4219c3aefee00
new file mode 100644
index 0000000..52940df
Binary files /dev/null and b/regress/corpus/dd76ad17bc40a3448a059e0d47c4219c3aefee00 differ
diff --git a/regress/corpus/dddc947d42e437a1618a05e49a6881ba7563c0ea b/regress/corpus/dddc947d42e437a1618a05e49a6881ba7563c0ea
new file mode 100644
index 0000000..b294437
--- /dev/null
+++ b/regress/corpus/dddc947d42e437a1618a05e49a6881ba7563c0ea
@@ -0,0 +1 @@
+¢þÿ¡

\ No newline at end of file
diff --git a/regress/corpus/ddff84d1abbaf8fbd088dcfb3e428947a6c5e2ee b/regress/corpus/ddff84d1abbaf8fbd088dcfb3e428947a6c5e2ee
new file mode 100644
index 0000000..1cb8628
Binary files /dev/null and b/regress/corpus/ddff84d1abbaf8fbd088dcfb3e428947a6c5e2ee differ
diff --git a/regress/corpus/de184c778b1882a5efe29b3d7bdfbb4d2011ecc0 b/regress/corpus/de184c778b1882a5efe29b3d7bdfbb4d2011ecc0
new file mode 100644
index 0000000..03c5bf0
--- /dev/null
+++ b/regress/corpus/de184c778b1882a5efe29b3d7bdfbb4d2011ecc0
@@ -0,0 +1 @@
+


















ùùùùùùùùùùùùùùù















\ No newline at end of file
diff --git a/regress/corpus/de9cfa547bdfa6436b81bdc706a3c478c48c4467 b/regress/corpus/de9cfa547bdfa6436b81bdc706a3c478c48c4467
new file mode 100644
index 0000000..7b7cc01
Binary files /dev/null and b/regress/corpus/de9cfa547bdfa6436b81bdc706a3c478c48c4467 differ
diff --git a/regress/corpus/deb3c397c32213f2b75cd57119b031bbcb7be43f b/regress/corpus/deb3c397c32213f2b75cd57119b031bbcb7be43f
new file mode 100644
index 0000000..adf7237
Binary files /dev/null and b/regress/corpus/deb3c397c32213f2b75cd57119b031bbcb7be43f differ
diff --git a/regress/corpus/df4164db2221bba5c7f05329a075c9d83d3d87e6 b/regress/corpus/df4164db2221bba5c7f05329a075c9d83d3d87e6
new file mode 100644
index 0000000..cdadc55
--- /dev/null
+++ b/regress/corpus/df4164db2221bba5c7f05329a075c9d83d3d87e6
@@ -0,0 +1 @@
+888888jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj88888È8888888888888888ŽŽŽŽŽ87(888888€
ôÿÿœ�MMM²²²
\ No newline at end of file
diff --git a/regress/corpus/dfd8f26ac2f31a537ce6801b8f2f9480d8cac2e0 b/regress/corpus/dfd8f26ac2f31a537ce6801b8f2f9480d8cac2e0
new file mode 100644
index 0000000..360ed18
Binary files /dev/null and b/regress/corpus/dfd8f26ac2f31a537ce6801b8f2f9480d8cac2e0 differ
diff --git a/regress/corpus/dfe250171862b9dd3a8d2ce85ac67cf9447ea72e b/regress/corpus/dfe250171862b9dd3a8d2ce85ac67cf9447ea72e
new file mode 100644
index 0000000..038089b
Binary files /dev/null and b/regress/corpus/dfe250171862b9dd3a8d2ce85ac67cf9447ea72e differ
diff --git a/regress/corpus/dff2c4628a2a1266d7bcbe4b416542c1e5cdb977 b/regress/corpus/dff2c4628a2a1266d7bcbe4b416542c1e5cdb977
new file mode 100644
index 0000000..e7f5593
Binary files /dev/null and b/regress/corpus/dff2c4628a2a1266d7bcbe4b416542c1e5cdb977 differ
diff --git a/regress/corpus/dff3784aaebbeea5b6d5987fca6dc30350001580 b/regress/corpus/dff3784aaebbeea5b6d5987fca6dc30350001580
new file mode 100644
index 0000000..451eee8
Binary files /dev/null and b/regress/corpus/dff3784aaebbeea5b6d5987fca6dc30350001580 differ
diff --git a/regress/corpus/e08e13c1cf3765c72c771ad64388f6553eefc71c b/regress/corpus/e08e13c1cf3765c72c771ad64388f6553eefc71c
new file mode 100644
index 0000000..02fcc0a
Binary files /dev/null and b/regress/corpus/e08e13c1cf3765c72c771ad64388f6553eefc71c differ
diff --git a/regress/corpus/e09a85d2024aad2ab46dc4af5a48cd96bd2ee6dc b/regress/corpus/e09a85d2024aad2ab46dc4af5a48cd96bd2ee6dc
new file mode 100644
index 0000000..1ca8979
Binary files /dev/null and b/regress/corpus/e09a85d2024aad2ab46dc4af5a48cd96bd2ee6dc differ
diff --git a/regress/corpus/e132f059f6744d273266b43321bb9a6494ec19cd b/regress/corpus/e132f059f6744d273266b43321bb9a6494ec19cd
new file mode 100644
index 0000000..796159b
Binary files /dev/null and b/regress/corpus/e132f059f6744d273266b43321bb9a6494ec19cd differ
diff --git a/regress/corpus/e140539d894bf242297292052e3eafd1ed93bee6 b/regress/corpus/e140539d894bf242297292052e3eafd1ed93bee6
new file mode 100644
index 0000000..bef89b8
Binary files /dev/null and b/regress/corpus/e140539d894bf242297292052e3eafd1ed93bee6 differ
diff --git a/regress/corpus/e1b0da4dae126c6cb5b8b6ffcd384b60565b8584 b/regress/corpus/e1b0da4dae126c6cb5b8b6ffcd384b60565b8584
new file mode 100644
index 0000000..0e97dc1
Binary files /dev/null and b/regress/corpus/e1b0da4dae126c6cb5b8b6ffcd384b60565b8584 differ
diff --git a/regress/corpus/e1f35730151de473d92a908921e98e1c2f4d536b b/regress/corpus/e1f35730151de473d92a908921e98e1c2f4d536b
new file mode 100644
index 0000000..56aadc8
Binary files /dev/null and b/regress/corpus/e1f35730151de473d92a908921e98e1c2f4d536b differ
diff --git a/regress/corpus/e240c7c2b834634aca316187f535e30f34b19e51 b/regress/corpus/e240c7c2b834634aca316187f535e30f34b19e51
new file mode 100644
index 0000000..c704cdf
Binary files /dev/null and b/regress/corpus/e240c7c2b834634aca316187f535e30f34b19e51 differ
diff --git a/regress/corpus/e2fa6d49b49d33791cc9ee9b77e46ae94872765e b/regress/corpus/e2fa6d49b49d33791cc9ee9b77e46ae94872765e
new file mode 100644
index 0000000..e234da4
Binary files /dev/null and b/regress/corpus/e2fa6d49b49d33791cc9ee9b77e46ae94872765e differ
diff --git a/regress/corpus/e322c0d655e44f1cb41d9c7b7a6bfd300365e857 b/regress/corpus/e322c0d655e44f1cb41d9c7b7a6bfd300365e857
new file mode 100644
index 0000000..44aae10
Binary files /dev/null and b/regress/corpus/e322c0d655e44f1cb41d9c7b7a6bfd300365e857 differ
diff --git a/regress/corpus/e37d7f638fe766aca7a51727dcad97d59ad9333e b/regress/corpus/e37d7f638fe766aca7a51727dcad97d59ad9333e
new file mode 100644
index 0000000..c7b28f9
Binary files /dev/null and b/regress/corpus/e37d7f638fe766aca7a51727dcad97d59ad9333e differ
diff --git a/regress/corpus/e384c702e9c134d94b1f6906f8c31c6742c0b68b b/regress/corpus/e384c702e9c134d94b1f6906f8c31c6742c0b68b
new file mode 100644
index 0000000..ed775ae
Binary files /dev/null and b/regress/corpus/e384c702e9c134d94b1f6906f8c31c6742c0b68b differ
diff --git a/regress/corpus/e3891bc58a5ceb354a3e041e9922545790b30433 b/regress/corpus/e3891bc58a5ceb354a3e041e9922545790b30433
new file mode 100644
index 0000000..3431bc3
Binary files /dev/null and b/regress/corpus/e3891bc58a5ceb354a3e041e9922545790b30433 differ
diff --git a/regress/corpus/e4500ef0752cdf295f3aefb24f4d73022df6a304 b/regress/corpus/e4500ef0752cdf295f3aefb24f4d73022df6a304
new file mode 100644
index 0000000..94f5b99
Binary files /dev/null and b/regress/corpus/e4500ef0752cdf295f3aefb24f4d73022df6a304 differ
diff --git a/regress/corpus/e4787610773945bdef327950c43e99c36ebe7cf9 b/regress/corpus/e4787610773945bdef327950c43e99c36ebe7cf9
new file mode 100644
index 0000000..9ae2b56
Binary files /dev/null and b/regress/corpus/e4787610773945bdef327950c43e99c36ebe7cf9 differ
diff --git a/regress/corpus/e5328fba79f51633f3a61cbebb182d5c7d0729bf b/regress/corpus/e5328fba79f51633f3a61cbebb182d5c7d0729bf
new file mode 100644
index 0000000..59f0a00
Binary files /dev/null and b/regress/corpus/e5328fba79f51633f3a61cbebb182d5c7d0729bf differ
diff --git a/regress/corpus/e5520aa429514d0c930ccd3a3ccc4a2a9902dde1 b/regress/corpus/e5520aa429514d0c930ccd3a3ccc4a2a9902dde1
new file mode 100644
index 0000000..e1090b2
--- /dev/null
+++ b/regress/corpus/e5520aa429514d0c930ccd3a3ccc4a2a9902dde1
@@ -0,0 +1 @@
+

ÿÿÿÿÿ¹ÿÿÿÿÿÿ¹ÿÿÿ££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££
\ No newline at end of file
diff --git a/regress/corpus/e5b9c92c85182e6bcb8a14c69695f28bc7576788 b/regress/corpus/e5b9c92c85182e6bcb8a14c69695f28bc7576788
new file mode 100644
index 0000000..ea49b9e
Binary files /dev/null and b/regress/corpus/e5b9c92c85182e6bcb8a14c69695f28bc7576788 differ
diff --git a/regress/corpus/e5c3ff18aff2d7fe75e822c648b1eeae21016d53 b/regress/corpus/e5c3ff18aff2d7fe75e822c648b1eeae21016d53
new file mode 100644
index 0000000..8a1e8e9
Binary files /dev/null and b/regress/corpus/e5c3ff18aff2d7fe75e822c648b1eeae21016d53 differ
diff --git a/regress/corpus/e61044b2726dcce1d40c93135118ea0e91d39788 b/regress/corpus/e61044b2726dcce1d40c93135118ea0e91d39788
new file mode 100644
index 0000000..b837b64
Binary files /dev/null and b/regress/corpus/e61044b2726dcce1d40c93135118ea0e91d39788 differ
diff --git a/regress/corpus/e63c01af8f117d4a46551ae8b7f4ef7e59bb1d78 b/regress/corpus/e63c01af8f117d4a46551ae8b7f4ef7e59bb1d78
new file mode 100644
index 0000000..749f53e
Binary files /dev/null and b/regress/corpus/e63c01af8f117d4a46551ae8b7f4ef7e59bb1d78 differ
diff --git a/regress/corpus/e65c7aa5b52962860c6b458ac762d52a00e6699f b/regress/corpus/e65c7aa5b52962860c6b458ac762d52a00e6699f
new file mode 100644
index 0000000..2ace6b1
Binary files /dev/null and b/regress/corpus/e65c7aa5b52962860c6b458ac762d52a00e6699f differ
diff --git a/regress/corpus/e6d2e54c25d5d871e3a7288e2473d274cb037cd1 b/regress/corpus/e6d2e54c25d5d871e3a7288e2473d274cb037cd1
new file mode 100644
index 0000000..ef09d62
Binary files /dev/null and b/regress/corpus/e6d2e54c25d5d871e3a7288e2473d274cb037cd1 differ
diff --git a/regress/corpus/e6d962028d17a600bfd1372ea001c2bc00345f53 b/regress/corpus/e6d962028d17a600bfd1372ea001c2bc00345f53
new file mode 100644
index 0000000..14c222a
Binary files /dev/null and b/regress/corpus/e6d962028d17a600bfd1372ea001c2bc00345f53 differ
diff --git a/regress/corpus/e718239d1d6feb67ce990dbc1eaec249c3838888 b/regress/corpus/e718239d1d6feb67ce990dbc1eaec249c3838888
new file mode 100644
index 0000000..e7e793a
--- /dev/null
+++ b/regress/corpus/e718239d1d6feb67ce990dbc1eaec249c3838888
@@ -0,0 +1 @@
+™„!
\ No newline at end of file
diff --git a/regress/corpus/e79e7436aa8290e68a342a3795e2c031fdc1b813 b/regress/corpus/e79e7436aa8290e68a342a3795e2c031fdc1b813
new file mode 100644
index 0000000..790f1ac
--- /dev/null
+++ b/regress/corpus/e79e7436aa8290e68a342a3795e2c031fdc1b813
@@ -0,0 +1 @@
+  
ÿý&
\ No newline at end of file
diff --git a/regress/corpus/e7ad2d8edec142a341e721c1e80a8403a229da95 b/regress/corpus/e7ad2d8edec142a341e721c1e80a8403a229da95
new file mode 100644
index 0000000..788b624
Binary files /dev/null and b/regress/corpus/e7ad2d8edec142a341e721c1e80a8403a229da95 differ
diff --git a/regress/corpus/e860560f2646adcdd8e72dd21b6d937a670dd8e9 b/regress/corpus/e860560f2646adcdd8e72dd21b6d937a670dd8e9
new file mode 100644
index 0000000..93a78a8
Binary files /dev/null and b/regress/corpus/e860560f2646adcdd8e72dd21b6d937a670dd8e9 differ
diff --git a/regress/corpus/e895477b645db771b82e3726cd5890f373e196f1 b/regress/corpus/e895477b645db771b82e3726cd5890f373e196f1
new file mode 100644
index 0000000..64c8aa4
Binary files /dev/null and b/regress/corpus/e895477b645db771b82e3726cd5890f373e196f1 differ
diff --git a/regress/corpus/e89ffdfc1cf802875b742f7e5509a805839f2797 b/regress/corpus/e89ffdfc1cf802875b742f7e5509a805839f2797
new file mode 100644
index 0000000..8efc9ac
Binary files /dev/null and b/regress/corpus/e89ffdfc1cf802875b742f7e5509a805839f2797 differ
diff --git a/regress/corpus/e92c80d956351aa1fea9f9b2b6953cb90902c15b b/regress/corpus/e92c80d956351aa1fea9f9b2b6953cb90902c15b
new file mode 100644
index 0000000..16c3d00
Binary files /dev/null and b/regress/corpus/e92c80d956351aa1fea9f9b2b6953cb90902c15b differ
diff --git a/regress/corpus/e98e9df4583b1d94c8fac1af87a7b8ec209b1262 b/regress/corpus/e98e9df4583b1d94c8fac1af87a7b8ec209b1262
new file mode 100644
index 0000000..bcfd346
Binary files /dev/null and b/regress/corpus/e98e9df4583b1d94c8fac1af87a7b8ec209b1262 differ
diff --git a/regress/corpus/e9a1b59d8d8ce934d5b0e4d5b6604291a669fed5 b/regress/corpus/e9a1b59d8d8ce934d5b0e4d5b6604291a669fed5
new file mode 100644
index 0000000..2280f1b
Binary files /dev/null and b/regress/corpus/e9a1b59d8d8ce934d5b0e4d5b6604291a669fed5 differ
diff --git a/regress/corpus/e9bec27dffe6ea73d5519dce854a4b731f4ad8bf b/regress/corpus/e9bec27dffe6ea73d5519dce854a4b731f4ad8bf
new file mode 100644
index 0000000..a353506
Binary files /dev/null and b/regress/corpus/e9bec27dffe6ea73d5519dce854a4b731f4ad8bf differ
diff --git a/regress/corpus/e9c2e972bf62e6bba22ac5f25cdd110f947130b1 b/regress/corpus/e9c2e972bf62e6bba22ac5f25cdd110f947130b1
new file mode 100644
index 0000000..ae27874
Binary files /dev/null and b/regress/corpus/e9c2e972bf62e6bba22ac5f25cdd110f947130b1 differ
diff --git a/regress/corpus/ea5cdece5c55d3499a92614d2c57e53c8550951b b/regress/corpus/ea5cdece5c55d3499a92614d2c57e53c8550951b
new file mode 100644
index 0000000..ce76510
Binary files /dev/null and b/regress/corpus/ea5cdece5c55d3499a92614d2c57e53c8550951b differ
diff --git a/regress/corpus/eabcaec749d26064bc4cb7db3229851c15d2695e b/regress/corpus/eabcaec749d26064bc4cb7db3229851c15d2695e
new file mode 100644
index 0000000..ac42c95
Binary files /dev/null and b/regress/corpus/eabcaec749d26064bc4cb7db3229851c15d2695e differ
diff --git a/regress/corpus/eadda6d32e4cc0131078c2848974b6047dee7933 b/regress/corpus/eadda6d32e4cc0131078c2848974b6047dee7933
new file mode 100644
index 0000000..ddc1669
Binary files /dev/null and b/regress/corpus/eadda6d32e4cc0131078c2848974b6047dee7933 differ
diff --git a/regress/corpus/eafcffb7044ce26f3394a621daa7d15ca16fc281 b/regress/corpus/eafcffb7044ce26f3394a621daa7d15ca16fc281
new file mode 100644
index 0000000..981c086
Binary files /dev/null and b/regress/corpus/eafcffb7044ce26f3394a621daa7d15ca16fc281 differ
diff --git a/regress/corpus/eb410760a7b41e840f9c7d12da3724a9d0d1e802 b/regress/corpus/eb410760a7b41e840f9c7d12da3724a9d0d1e802
new file mode 100644
index 0000000..7945a9c
Binary files /dev/null and b/regress/corpus/eb410760a7b41e840f9c7d12da3724a9d0d1e802 differ
diff --git a/regress/corpus/ebab52f062927efb574ad86c3e0ab28eb5d27068 b/regress/corpus/ebab52f062927efb574ad86c3e0ab28eb5d27068
new file mode 100644
index 0000000..ca6757d
Binary files /dev/null and b/regress/corpus/ebab52f062927efb574ad86c3e0ab28eb5d27068 differ
diff --git a/regress/corpus/ec25cccce6c9567d45603f551339b94d5fc69188 b/regress/corpus/ec25cccce6c9567d45603f551339b94d5fc69188
new file mode 100644
index 0000000..9b18e4b
Binary files /dev/null and b/regress/corpus/ec25cccce6c9567d45603f551339b94d5fc69188 differ
diff --git a/regress/corpus/ec350d764246e941a585ba63958851664b1e3d50 b/regress/corpus/ec350d764246e941a585ba63958851664b1e3d50
new file mode 100644
index 0000000..b197247
Binary files /dev/null and b/regress/corpus/ec350d764246e941a585ba63958851664b1e3d50 differ
diff --git a/regress/corpus/ec41abd5b47814d571e107487c9030847bc1f2fe b/regress/corpus/ec41abd5b47814d571e107487c9030847bc1f2fe
new file mode 100644
index 0000000..d928ac5
Binary files /dev/null and b/regress/corpus/ec41abd5b47814d571e107487c9030847bc1f2fe differ
diff --git a/regress/corpus/ec4f91933aca2727c1793e46dae0278198fbe346 b/regress/corpus/ec4f91933aca2727c1793e46dae0278198fbe346
new file mode 100644
index 0000000..1f7920d
Binary files /dev/null and b/regress/corpus/ec4f91933aca2727c1793e46dae0278198fbe346 differ
diff --git a/regress/corpus/ec710d628a65b8934dbd1038f84dc0af88b70829 b/regress/corpus/ec710d628a65b8934dbd1038f84dc0af88b70829
new file mode 100644
index 0000000..f671560
Binary files /dev/null and b/regress/corpus/ec710d628a65b8934dbd1038f84dc0af88b70829 differ
diff --git a/regress/corpus/ec912e3eb87a1df645f87db60d539e47be5fa1cf b/regress/corpus/ec912e3eb87a1df645f87db60d539e47be5fa1cf
new file mode 100644
index 0000000..3a58b7d
Binary files /dev/null and b/regress/corpus/ec912e3eb87a1df645f87db60d539e47be5fa1cf differ
diff --git a/regress/corpus/ed7c73582120780c5353917d5dfbd8adaf389b30 b/regress/corpus/ed7c73582120780c5353917d5dfbd8adaf389b30
new file mode 100644
index 0000000..7d5e6de
Binary files /dev/null and b/regress/corpus/ed7c73582120780c5353917d5dfbd8adaf389b30 differ
diff --git a/regress/corpus/edd7e71e86d9415d732cefdf37e66393806c7e47 b/regress/corpus/edd7e71e86d9415d732cefdf37e66393806c7e47
new file mode 100644
index 0000000..b2449cf
Binary files /dev/null and b/regress/corpus/edd7e71e86d9415d732cefdf37e66393806c7e47 differ
diff --git a/regress/corpus/ee5a2c28b1c668bca4c522eacac516bd93c33cb6 b/regress/corpus/ee5a2c28b1c668bca4c522eacac516bd93c33cb6
new file mode 100644
index 0000000..30b1bcb
Binary files /dev/null and b/regress/corpus/ee5a2c28b1c668bca4c522eacac516bd93c33cb6 differ
diff --git a/regress/corpus/ee7f85163d9e299365e1f7e8016dfcb563f22310 b/regress/corpus/ee7f85163d9e299365e1f7e8016dfcb563f22310
new file mode 100644
index 0000000..76ba113
Binary files /dev/null and b/regress/corpus/ee7f85163d9e299365e1f7e8016dfcb563f22310 differ
diff --git a/regress/corpus/ee9c74e4c19beefe26bc720f48f3c175b4180f98 b/regress/corpus/ee9c74e4c19beefe26bc720f48f3c175b4180f98
new file mode 100644
index 0000000..4151c2c
Binary files /dev/null and b/regress/corpus/ee9c74e4c19beefe26bc720f48f3c175b4180f98 differ
diff --git a/regress/corpus/eea32dfe8837f35252f1dbe6f5b9083b1127f82e b/regress/corpus/eea32dfe8837f35252f1dbe6f5b9083b1127f82e
new file mode 100644
index 0000000..cb64303
Binary files /dev/null and b/regress/corpus/eea32dfe8837f35252f1dbe6f5b9083b1127f82e differ
diff --git a/regress/corpus/ef6b146f8ac3d4f0a3178c2b4f259f6cae683657 b/regress/corpus/ef6b146f8ac3d4f0a3178c2b4f259f6cae683657
new file mode 100644
index 0000000..7eb731a
Binary files /dev/null and b/regress/corpus/ef6b146f8ac3d4f0a3178c2b4f259f6cae683657 differ
diff --git a/regress/corpus/ef960b5a3de322d2cc6491a07c71f660eabb8c25 b/regress/corpus/ef960b5a3de322d2cc6491a07c71f660eabb8c25
new file mode 100644
index 0000000..3f6a866
Binary files /dev/null and b/regress/corpus/ef960b5a3de322d2cc6491a07c71f660eabb8c25 differ
diff --git a/regress/corpus/efda36bb855788b972bbc56e28932e18fb778198 b/regress/corpus/efda36bb855788b972bbc56e28932e18fb778198
new file mode 100644
index 0000000..7fa1a6a
Binary files /dev/null and b/regress/corpus/efda36bb855788b972bbc56e28932e18fb778198 differ
diff --git a/regress/corpus/f033b5595474d07a152d69e5af757231075718dc b/regress/corpus/f033b5595474d07a152d69e5af757231075718dc
new file mode 100644
index 0000000..e5d3f1d
Binary files /dev/null and b/regress/corpus/f033b5595474d07a152d69e5af757231075718dc differ
diff --git a/regress/corpus/f0534dd7e9c3284b578380927a4d0780d579549b b/regress/corpus/f0534dd7e9c3284b578380927a4d0780d579549b
new file mode 100644
index 0000000..85a745d
Binary files /dev/null and b/regress/corpus/f0534dd7e9c3284b578380927a4d0780d579549b differ
diff --git a/regress/corpus/f063a6fe0d0cc835eb24e47dde92ff07f52331ca b/regress/corpus/f063a6fe0d0cc835eb24e47dde92ff07f52331ca
new file mode 100644
index 0000000..5e22884
Binary files /dev/null and b/regress/corpus/f063a6fe0d0cc835eb24e47dde92ff07f52331ca differ
diff --git a/regress/corpus/f083a64658ded20380f359df1a1239df0cf17dcf b/regress/corpus/f083a64658ded20380f359df1a1239df0cf17dcf
new file mode 100644
index 0000000..9ab9600
Binary files /dev/null and b/regress/corpus/f083a64658ded20380f359df1a1239df0cf17dcf differ
diff --git a/regress/corpus/f0a88bb54525d2c64217b6b2442cf1eb853303ea b/regress/corpus/f0a88bb54525d2c64217b6b2442cf1eb853303ea
new file mode 100644
index 0000000..83264f5
--- /dev/null
+++ b/regress/corpus/f0a88bb54525d2c64217b6b2442cf1eb853303ea
@@ -0,0 +1 @@
+

ÿÿÿ¹ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¹ÿÿÿ¹ÿÿÿÿÿÿÿÿ
\ No newline at end of file
diff --git a/regress/corpus/f0c3dac7fd48e7087330fa5c10f985fae395f57c b/regress/corpus/f0c3dac7fd48e7087330fa5c10f985fae395f57c
new file mode 100644
index 0000000..5f5dd84
Binary files /dev/null and b/regress/corpus/f0c3dac7fd48e7087330fa5c10f985fae395f57c differ
diff --git a/regress/corpus/f11b495ce816cefb46c6ea3d0e8b858faa19cb7c b/regress/corpus/f11b495ce816cefb46c6ea3d0e8b858faa19cb7c
new file mode 100644
index 0000000..11b639a
Binary files /dev/null and b/regress/corpus/f11b495ce816cefb46c6ea3d0e8b858faa19cb7c differ
diff --git a/regress/corpus/f12f6a6a6a22c60a2c6c11f6a31a489eb396634c b/regress/corpus/f12f6a6a6a22c60a2c6c11f6a31a489eb396634c
new file mode 100644
index 0000000..a111ced
Binary files /dev/null and b/regress/corpus/f12f6a6a6a22c60a2c6c11f6a31a489eb396634c differ
diff --git a/regress/corpus/f18d799d4ab9e22c434fe4f4c0fed854d325daa3 b/regress/corpus/f18d799d4ab9e22c434fe4f4c0fed854d325daa3
new file mode 100644
index 0000000..60ea9c1
Binary files /dev/null and b/regress/corpus/f18d799d4ab9e22c434fe4f4c0fed854d325daa3 differ
diff --git a/regress/corpus/f254685da142f046cf7feced5fcdd8b2c214cd20 b/regress/corpus/f254685da142f046cf7feced5fcdd8b2c214cd20
new file mode 100644
index 0000000..6e8fc4d
Binary files /dev/null and b/regress/corpus/f254685da142f046cf7feced5fcdd8b2c214cd20 differ
diff --git a/regress/corpus/f2cbbba8b310e42c48b54a3fe1a6037dba9406cd b/regress/corpus/f2cbbba8b310e42c48b54a3fe1a6037dba9406cd
new file mode 100644
index 0000000..1f6fd82
Binary files /dev/null and b/regress/corpus/f2cbbba8b310e42c48b54a3fe1a6037dba9406cd differ
diff --git a/regress/corpus/f307eb6024a81f0239d406c3d7d6a101e46df982 b/regress/corpus/f307eb6024a81f0239d406c3d7d6a101e46df982
new file mode 100644
index 0000000..2e0f6af
Binary files /dev/null and b/regress/corpus/f307eb6024a81f0239d406c3d7d6a101e46df982 differ
diff --git a/regress/corpus/f33f932b512711df18ef9a4259ba5f4981b35cde b/regress/corpus/f33f932b512711df18ef9a4259ba5f4981b35cde
new file mode 100644
index 0000000..7c8eeb7
Binary files /dev/null and b/regress/corpus/f33f932b512711df18ef9a4259ba5f4981b35cde differ
diff --git a/regress/corpus/f363c6bdef3fb8a598a880ab6eb7853cd7a3d1e7 b/regress/corpus/f363c6bdef3fb8a598a880ab6eb7853cd7a3d1e7
new file mode 100644
index 0000000..dd92587
Binary files /dev/null and b/regress/corpus/f363c6bdef3fb8a598a880ab6eb7853cd7a3d1e7 differ
diff --git a/regress/corpus/f3ac798e103f4e43bb648aa07991089d7af5f339 b/regress/corpus/f3ac798e103f4e43bb648aa07991089d7af5f339
new file mode 100644
index 0000000..f2abc6f
Binary files /dev/null and b/regress/corpus/f3ac798e103f4e43bb648aa07991089d7af5f339 differ
diff --git a/regress/corpus/f3bda844df8a4d605ebb09fffa58a133fa9aca58 b/regress/corpus/f3bda844df8a4d605ebb09fffa58a133fa9aca58
new file mode 100644
index 0000000..f698649
Binary files /dev/null and b/regress/corpus/f3bda844df8a4d605ebb09fffa58a133fa9aca58 differ
diff --git a/regress/corpus/f45bb27ee477adecd3842dbeeaccfb952c1bfb8e b/regress/corpus/f45bb27ee477adecd3842dbeeaccfb952c1bfb8e
new file mode 100644
index 0000000..063ee8c
--- /dev/null
+++ b/regress/corpus/f45bb27ee477adecd3842dbeeaccfb952c1bfb8e
@@ -0,0 +1 @@
+8ýªªªªªªªªª
\ No newline at end of file
diff --git a/regress/corpus/f48c7894588237737a17ef04cccc9f24f01b8a61 b/regress/corpus/f48c7894588237737a17ef04cccc9f24f01b8a61
new file mode 100644
index 0000000..513f273
Binary files /dev/null and b/regress/corpus/f48c7894588237737a17ef04cccc9f24f01b8a61 differ
diff --git a/regress/corpus/f4a501dffbd71e6ac93d89cb92f971e832d1be45 b/regress/corpus/f4a501dffbd71e6ac93d89cb92f971e832d1be45
new file mode 100644
index 0000000..ebc19a5
Binary files /dev/null and b/regress/corpus/f4a501dffbd71e6ac93d89cb92f971e832d1be45 differ
diff --git a/regress/corpus/f51f2cc2931530b44c9d51a442a963aab3b6bfa3 b/regress/corpus/f51f2cc2931530b44c9d51a442a963aab3b6bfa3
new file mode 100644
index 0000000..92f91a5
Binary files /dev/null and b/regress/corpus/f51f2cc2931530b44c9d51a442a963aab3b6bfa3 differ
diff --git a/regress/corpus/f5408240ad667f408df49f194a8a4636276b3885 b/regress/corpus/f5408240ad667f408df49f194a8a4636276b3885
new file mode 100644
index 0000000..7371ab2
Binary files /dev/null and b/regress/corpus/f5408240ad667f408df49f194a8a4636276b3885 differ
diff --git a/regress/corpus/f57af62b211f6ace2d7ff9565ada2fb9fa2baee1 b/regress/corpus/f57af62b211f6ace2d7ff9565ada2fb9fa2baee1
new file mode 100644
index 0000000..701c3f5
Binary files /dev/null and b/regress/corpus/f57af62b211f6ace2d7ff9565ada2fb9fa2baee1 differ
diff --git a/regress/corpus/f5cea6cb12cea0e384dc483d4bc06a149742cb21 b/regress/corpus/f5cea6cb12cea0e384dc483d4bc06a149742cb21
new file mode 100644
index 0000000..91db9c1
Binary files /dev/null and b/regress/corpus/f5cea6cb12cea0e384dc483d4bc06a149742cb21 differ
diff --git a/regress/corpus/f662bb3e9dd5db3b30e321585701d5d940509f18 b/regress/corpus/f662bb3e9dd5db3b30e321585701d5d940509f18
new file mode 100644
index 0000000..0cbff01
Binary files /dev/null and b/regress/corpus/f662bb3e9dd5db3b30e321585701d5d940509f18 differ
diff --git a/regress/corpus/f66928adbe8c1f0fb5eb95a974a027d6bd385fb0 b/regress/corpus/f66928adbe8c1f0fb5eb95a974a027d6bd385fb0
new file mode 100644
index 0000000..a023692
Binary files /dev/null and b/regress/corpus/f66928adbe8c1f0fb5eb95a974a027d6bd385fb0 differ
diff --git a/regress/corpus/f67d44924d8e60bee8aca304e6f113e090d714f7 b/regress/corpus/f67d44924d8e60bee8aca304e6f113e090d714f7
new file mode 100644
index 0000000..a2740c9
Binary files /dev/null and b/regress/corpus/f67d44924d8e60bee8aca304e6f113e090d714f7 differ
diff --git a/regress/corpus/f6b5ab62a3206f100b5ab06d35cc307c351b3dbd b/regress/corpus/f6b5ab62a3206f100b5ab06d35cc307c351b3dbd
new file mode 100644
index 0000000..fb9aa35
Binary files /dev/null and b/regress/corpus/f6b5ab62a3206f100b5ab06d35cc307c351b3dbd differ
diff --git a/regress/corpus/f6eb289f4cd01f35d79743acbf9bab6acb5d32a8 b/regress/corpus/f6eb289f4cd01f35d79743acbf9bab6acb5d32a8
new file mode 100644
index 0000000..e923af5
Binary files /dev/null and b/regress/corpus/f6eb289f4cd01f35d79743acbf9bab6acb5d32a8 differ
diff --git a/regress/corpus/f71c7415b7594fb606768feaaec10435e95acacf b/regress/corpus/f71c7415b7594fb606768feaaec10435e95acacf
new file mode 100644
index 0000000..09351dc
Binary files /dev/null and b/regress/corpus/f71c7415b7594fb606768feaaec10435e95acacf differ
diff --git a/regress/corpus/f758b51e70be89991cce14f676790f2406cccdfd b/regress/corpus/f758b51e70be89991cce14f676790f2406cccdfd
new file mode 100644
index 0000000..a75dff1
Binary files /dev/null and b/regress/corpus/f758b51e70be89991cce14f676790f2406cccdfd differ
diff --git a/regress/corpus/f771f6cc2138150ca2d9fa3fbae88e81a175cc70 b/regress/corpus/f771f6cc2138150ca2d9fa3fbae88e81a175cc70
new file mode 100644
index 0000000..c53441a
Binary files /dev/null and b/regress/corpus/f771f6cc2138150ca2d9fa3fbae88e81a175cc70 differ
diff --git a/regress/corpus/f7986b3839dbb93a11a57682836f9b96c5fb32a8 b/regress/corpus/f7986b3839dbb93a11a57682836f9b96c5fb32a8
new file mode 100644
index 0000000..ffc1364
Binary files /dev/null and b/regress/corpus/f7986b3839dbb93a11a57682836f9b96c5fb32a8 differ
diff --git a/regress/corpus/f7cc693b58c88c94a6c351bb1574971149876eba b/regress/corpus/f7cc693b58c88c94a6c351bb1574971149876eba
new file mode 100644
index 0000000..674447b
Binary files /dev/null and b/regress/corpus/f7cc693b58c88c94a6c351bb1574971149876eba differ
diff --git a/regress/corpus/f7d13649b99d5fe05b278f1521ef089a610747cc b/regress/corpus/f7d13649b99d5fe05b278f1521ef089a610747cc
new file mode 100644
index 0000000..60278ec
Binary files /dev/null and b/regress/corpus/f7d13649b99d5fe05b278f1521ef089a610747cc differ
diff --git a/regress/corpus/f83e05a5e5406f7e75a185a2b88add4cedca8ef6 b/regress/corpus/f83e05a5e5406f7e75a185a2b88add4cedca8ef6
new file mode 100644
index 0000000..7e93539
Binary files /dev/null and b/regress/corpus/f83e05a5e5406f7e75a185a2b88add4cedca8ef6 differ
diff --git a/regress/corpus/f8863d11f14cc233574f3ae1b845cecb00709562 b/regress/corpus/f8863d11f14cc233574f3ae1b845cecb00709562
new file mode 100644
index 0000000..118d17d
Binary files /dev/null and b/regress/corpus/f8863d11f14cc233574f3ae1b845cecb00709562 differ
diff --git a/regress/corpus/f9eb06b4b1546382e04e278e55c4961354b05780 b/regress/corpus/f9eb06b4b1546382e04e278e55c4961354b05780
new file mode 100644
index 0000000..6aca7c2
Binary files /dev/null and b/regress/corpus/f9eb06b4b1546382e04e278e55c4961354b05780 differ
diff --git a/regress/corpus/f9f5c6688b589d5652b6a1c26fdda8cfe5857104 b/regress/corpus/f9f5c6688b589d5652b6a1c26fdda8cfe5857104
new file mode 100644
index 0000000..eaedb65
Binary files /dev/null and b/regress/corpus/f9f5c6688b589d5652b6a1c26fdda8cfe5857104 differ
diff --git a/regress/corpus/fa4fc9285df9268b4515356b2c72a7b2727b73c6 b/regress/corpus/fa4fc9285df9268b4515356b2c72a7b2727b73c6
new file mode 100644
index 0000000..475ade7
Binary files /dev/null and b/regress/corpus/fa4fc9285df9268b4515356b2c72a7b2727b73c6 differ
diff --git a/regress/corpus/fa639f8272b21a4c48fb879da6bd149979240dd3 b/regress/corpus/fa639f8272b21a4c48fb879da6bd149979240dd3
new file mode 100644
index 0000000..3eed004
Binary files /dev/null and b/regress/corpus/fa639f8272b21a4c48fb879da6bd149979240dd3 differ
diff --git a/regress/corpus/fa97ac3d502cbf0e528d7fd0c095272307182bea b/regress/corpus/fa97ac3d502cbf0e528d7fd0c095272307182bea
new file mode 100644
index 0000000..f50276b
Binary files /dev/null and b/regress/corpus/fa97ac3d502cbf0e528d7fd0c095272307182bea differ
diff --git a/regress/corpus/fa9c6165b833407ca1ef6c0fda37f529110a517d b/regress/corpus/fa9c6165b833407ca1ef6c0fda37f529110a517d
new file mode 100644
index 0000000..b13983b
Binary files /dev/null and b/regress/corpus/fa9c6165b833407ca1ef6c0fda37f529110a517d differ
diff --git a/regress/corpus/faec21bbb347c599b994fa4327f695d057d9dfc5 b/regress/corpus/faec21bbb347c599b994fa4327f695d057d9dfc5
new file mode 100644
index 0000000..8668580
Binary files /dev/null and b/regress/corpus/faec21bbb347c599b994fa4327f695d057d9dfc5 differ
diff --git a/regress/corpus/fb2ffbaa6eba45dfa3a64adc986b1014b0c41caf b/regress/corpus/fb2ffbaa6eba45dfa3a64adc986b1014b0c41caf
new file mode 100644
index 0000000..2956c42
Binary files /dev/null and b/regress/corpus/fb2ffbaa6eba45dfa3a64adc986b1014b0c41caf differ
diff --git a/regress/corpus/fb5d23c41634bc2ccdd2b71d3f4773020859d54c b/regress/corpus/fb5d23c41634bc2ccdd2b71d3f4773020859d54c
new file mode 100644
index 0000000..3128683
Binary files /dev/null and b/regress/corpus/fb5d23c41634bc2ccdd2b71d3f4773020859d54c differ
diff --git a/regress/corpus/fc0b5ce130e7629cfecb7a8d0e07b391800b04aa b/regress/corpus/fc0b5ce130e7629cfecb7a8d0e07b391800b04aa
new file mode 100644
index 0000000..979b163
Binary files /dev/null and b/regress/corpus/fc0b5ce130e7629cfecb7a8d0e07b391800b04aa differ
diff --git a/regress/corpus/fc28b7061090689df41fdea53f16ace9afc162a5 b/regress/corpus/fc28b7061090689df41fdea53f16ace9afc162a5
new file mode 100644
index 0000000..623f815
Binary files /dev/null and b/regress/corpus/fc28b7061090689df41fdea53f16ace9afc162a5 differ
diff --git a/regress/corpus/fcb798c6e61b3dc04b3737039ec0aff210f904c5 b/regress/corpus/fcb798c6e61b3dc04b3737039ec0aff210f904c5
new file mode 100644
index 0000000..a50164b
Binary files /dev/null and b/regress/corpus/fcb798c6e61b3dc04b3737039ec0aff210f904c5 differ
diff --git a/regress/corpus/fcff85c5edf606f2da5bea520350f28a96c14dd7 b/regress/corpus/fcff85c5edf606f2da5bea520350f28a96c14dd7
new file mode 100644
index 0000000..37e8963
Binary files /dev/null and b/regress/corpus/fcff85c5edf606f2da5bea520350f28a96c14dd7 differ
diff --git a/regress/corpus/fd2f97ea0f894f0ca362a5f8c08a5014f7bb10f3 b/regress/corpus/fd2f97ea0f894f0ca362a5f8c08a5014f7bb10f3
new file mode 100644
index 0000000..c6db301
Binary files /dev/null and b/regress/corpus/fd2f97ea0f894f0ca362a5f8c08a5014f7bb10f3 differ
diff --git a/regress/corpus/fd454f8f9408fef5391200bc93057db0e0bd3d85 b/regress/corpus/fd454f8f9408fef5391200bc93057db0e0bd3d85
new file mode 100644
index 0000000..ea686d8
Binary files /dev/null and b/regress/corpus/fd454f8f9408fef5391200bc93057db0e0bd3d85 differ
diff --git a/regress/corpus/fd4fd71b6694ee8bc4cc7df5bc1268b3560acbc3 b/regress/corpus/fd4fd71b6694ee8bc4cc7df5bc1268b3560acbc3
new file mode 100644
index 0000000..e5f33af
Binary files /dev/null and b/regress/corpus/fd4fd71b6694ee8bc4cc7df5bc1268b3560acbc3 differ
diff --git a/regress/corpus/fd7b27922595d3f5481a413ab74d6bc75561517c b/regress/corpus/fd7b27922595d3f5481a413ab74d6bc75561517c
new file mode 100644
index 0000000..f3c488b
Binary files /dev/null and b/regress/corpus/fd7b27922595d3f5481a413ab74d6bc75561517c differ
diff --git a/regress/corpus/fd8a5f544cf6b3dd642f38ef9436f80a76e4f13e b/regress/corpus/fd8a5f544cf6b3dd642f38ef9436f80a76e4f13e
new file mode 100644
index 0000000..4d79050
Binary files /dev/null and b/regress/corpus/fd8a5f544cf6b3dd642f38ef9436f80a76e4f13e differ
diff --git a/regress/corpus/fe34fc899af30caf165d598d43a41cd8e6bc1765 b/regress/corpus/fe34fc899af30caf165d598d43a41cd8e6bc1765
new file mode 100644
index 0000000..035e90f
Binary files /dev/null and b/regress/corpus/fe34fc899af30caf165d598d43a41cd8e6bc1765 differ
diff --git a/regress/corpus/fe6ea2796566c507cfdb690d1196dcbdcfab9ff5 b/regress/corpus/fe6ea2796566c507cfdb690d1196dcbdcfab9ff5
new file mode 100644
index 0000000..78e4e86
Binary files /dev/null and b/regress/corpus/fe6ea2796566c507cfdb690d1196dcbdcfab9ff5 differ
diff --git a/regress/corpus/fe7e22b8ddf51267bc7b52640e12e985828d2915 b/regress/corpus/fe7e22b8ddf51267bc7b52640e12e985828d2915
new file mode 100644
index 0000000..4cb0bb0
Binary files /dev/null and b/regress/corpus/fe7e22b8ddf51267bc7b52640e12e985828d2915 differ
diff --git a/regress/corpus/feb7a9c60c58a2d56576522c186a4118252bc6d8 b/regress/corpus/feb7a9c60c58a2d56576522c186a4118252bc6d8
new file mode 100644
index 0000000..9fcd7ea
Binary files /dev/null and b/regress/corpus/feb7a9c60c58a2d56576522c186a4118252bc6d8 differ
diff --git a/regress/corpus/fed13cef825fc50e9dad61fb0f9ca685350064ca b/regress/corpus/fed13cef825fc50e9dad61fb0f9ca685350064ca
new file mode 100644
index 0000000..5455658
Binary files /dev/null and b/regress/corpus/fed13cef825fc50e9dad61fb0f9ca685350064ca differ
diff --git a/regress/corpus/fef074366f9d7dc652a7cea750e2738f310c34e2 b/regress/corpus/fef074366f9d7dc652a7cea750e2738f310c34e2
new file mode 100644
index 0000000..088ddac
Binary files /dev/null and b/regress/corpus/fef074366f9d7dc652a7cea750e2738f310c34e2 differ
diff --git a/regress/corpus/ff4ba34380cd42a2aace224feec127c23f46deeb b/regress/corpus/ff4ba34380cd42a2aace224feec127c23f46deeb
new file mode 100644
index 0000000..846da26
Binary files /dev/null and b/regress/corpus/ff4ba34380cd42a2aace224feec127c23f46deeb differ
diff --git a/regress/corpus/ff87afa73e81f9bfb66961ba01311b9161c3f4f1 b/regress/corpus/ff87afa73e81f9bfb66961ba01311b9161c3f4f1
new file mode 100644
index 0000000..e8d1699
Binary files /dev/null and b/regress/corpus/ff87afa73e81f9bfb66961ba01311b9161c3f4f1 differ
diff --git a/regress/corpus/selector_domain b/regress/corpus/selector_domain
new file mode 100644
index 0000000..6b2aaa7
--- /dev/null
+++ b/regress/corpus/selector_domain
@@ -0,0 +1 @@
+

\ No newline at end of file
diff --git a/regress/corpus/selector_packet b/regress/corpus/selector_packet
new file mode 100644
index 0000000..f76dd23
Binary files /dev/null and b/regress/corpus/selector_packet differ
diff --git a/regress/corpus/selector_rr b/regress/corpus/selector_rr
new file mode 100644
index 0000000..25cb955
--- /dev/null
+++ b/regress/corpus/selector_rr
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/regress/crash-1ffe2d52cb820525e38d1605a0a359eebdb398e7 b/regress/crash-1ffe2d52cb820525e38d1605a0a359eebdb398e7
new file mode 100644
index 0000000..7f212f6
Binary files /dev/null and b/regress/crash-1ffe2d52cb820525e38d1605a0a359eebdb398e7 differ
diff --git a/regress/crash-6a5c9ebb65a8aa4cb57aeccfb19b4d892093e418 b/regress/crash-6a5c9ebb65a8aa4cb57aeccfb19b4d892093e418
new file mode 100644
index 0000000..5321e94
Binary files /dev/null and b/regress/crash-6a5c9ebb65a8aa4cb57aeccfb19b4d892093e418 differ
diff --git a/regress/crash-f68d01ae9b54206705c49ddf24eedb6177b01b8c b/regress/crash-f68d01ae9b54206705c49ddf24eedb6177b01b8c
new file mode 100644
index 0000000..a5ae2f5
Binary files /dev/null and b/regress/crash-f68d01ae9b54206705c49ddf24eedb6177b01b8c differ
diff --git a/regress/fuzz_dns.c b/regress/fuzz_dns.c
new file mode 100644
index 0000000..8997d0e
--- /dev/null
+++ b/regress/fuzz_dns.c
@@ -0,0 +1,273 @@
+/*
+ * Fuzz harness for dns.c using libFuzzer
+ *
+ * Build with:
+ *   clang -g -O1 -fsanitize=fuzzer,address,undefined \
+ *         -DDNS_DEBUG=0 -I../src -o fuzz_dns fuzz_dns.c
+ *
+ * Run with:
+ *   ./fuzz_dns corpus/ -max_len=4096
+ */
+
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "dns.c"
+
+/*
+ * Fuzz target 1: Parse a complete DNS packet
+ * This exercises the most attack surface - packet parsing, RR iteration,
+ * name decompression, and all RR type parsers.
+ */
+static void fuzz_packet_parse(const uint8_t *data, size_t size) {
+    struct dns_packet *P;
+    struct dns_rr rr;
+    struct dns_rr_i I;
+    union dns_any any;
+    char buf[1024];
+    int error;
+
+    if (size < 12 || size > 65535)
+        return;
+
+    P = dns_p_make(size, NULL);
+    if (!P)
+        return;
+
+    memcpy(P->data, data, size);
+    P->end = size;
+
+    /* Try to iterate all sections */
+    for (int section = DNS_S_QD; section <= DNS_S_AR; section <<= 1) {
+        memset(&I, 0, sizeof(I));
+        I.section = section;
+        dns_rr_i_init(&I, P);
+
+        while (dns_rr_grep(&rr, 1, &I, P, &error)) {
+            /* Try to parse the RR */
+            dns_any_init(&any, sizeof(any));
+            if (dns_any_parse(&any, &rr, P) != 0)
+                continue;
+
+            /* Try to print the RR - only if parse succeeded */
+            dns_any_print(buf, sizeof(buf), &any, rr.type);
+
+            /* Try to get the name */
+            dns_d_expand(buf, sizeof(buf), rr.dn.p, P, &error);
+        }
+    }
+
+    free(P);
+}
+
+/*
+ * Fuzz target 2: Domain name operations
+ * Test name expansion, compression, comparison
+ */
+static void fuzz_domain_name(const uint8_t *data, size_t size) {
+    struct dns_packet *P;
+    char name[DNS_D_MAXNAME + 1];
+    int error;
+
+    if (size < 12 || size > 4096)
+        return;
+
+    P = dns_p_make(size, NULL);
+    if (!P)
+        return;
+
+    memcpy(P->data, data, size);
+    P->end = size;
+
+    /* Try expanding names at various offsets */
+    for (unsigned offset = 12; offset < size && offset < 512; offset++) {
+        dns_d_expand(name, sizeof(name), offset, P, &error);
+        dns_d_skip(offset, P);
+    }
+
+    /* Try name comparison */
+    if (size >= 24) {
+        dns_d_cname(name, sizeof(name), (char *)data + 12,
+                    DNS_PP_MIN(size - 12, DNS_D_MAXNAME), P, &error);
+    }
+
+    free(P);
+}
+
+/*
+ * Fuzz target 3: Individual RR type parsers
+ * Directly test each RR parser with raw RDATA
+ */
+static void fuzz_rr_parsers(const uint8_t *data, size_t size) {
+    struct dns_packet *P;
+    struct dns_rr rr = {0};
+    union dns_any any;
+    char buf[4096];
+
+    if (size < 1 || size > 2048)
+        return;
+
+    /* Allocate packet with enough space for the data */
+    P = dns_p_make(size + 12, NULL);
+    if (!P)
+        return;
+
+    /* Set up a minimal packet with just the RDATA */
+    memcpy(P->data, data, size);
+    P->end = size;
+
+    rr.rd.p = 0;
+    rr.rd.len = size;
+
+    /* Use first byte to select RR type to test */
+    static const enum dns_type types[] = {
+        DNS_T_A, DNS_T_NS, DNS_T_CNAME, DNS_T_SOA, DNS_T_PTR,
+        DNS_T_MX, DNS_T_TXT, DNS_T_AAAA, DNS_T_SRV,
+        DNS_T_OPT, DNS_T_SSHFP, DNS_T_DS, DNS_T_RRSIG, DNS_T_NSEC,
+        DNS_T_DNSKEY, DNS_T_NSEC3, DNS_T_TLSA, DNS_T_SVCB, DNS_T_HTTPS,
+        DNS_T_CAA, DNS_T_URI
+    };
+
+    if (size < 2) {
+        free(P);
+        return;
+    }
+
+    int type_idx = data[0] % (sizeof(types) / sizeof(types[0]));
+    rr.type = types[type_idx];
+    rr.rd.p = 1;  /* Skip the type selector byte */
+    rr.rd.len = size - 1;
+
+    dns_any_init(&any, sizeof(any));
+    if (dns_any_parse(&any, &rr, P) == 0) {
+        dns_any_print(buf, sizeof(buf), &any, rr.type);
+    }
+
+    free(P);
+}
+
+/*
+ * Fuzz target 4: Resolver configuration parsing
+ */
+static void fuzz_resconf(const uint8_t *data, size_t size) {
+    struct dns_resolv_conf *resconf;
+    int error;
+
+    if (size > 8192)
+        return;
+
+    resconf = dns_resconf_open(&error);
+    if (!resconf)
+        return;
+
+    /* Create a temporary buffer with null terminator for line parsing */
+    char *buf = malloc(size + 1);
+    if (buf) {
+        memcpy(buf, data, size);
+        buf[size] = '\0';
+
+        /* Simulate parsing resolv.conf lines */
+        char *line = buf;
+        char *end;
+        while ((end = strchr(line, '\n')) != NULL) {
+            *end = '\0';
+            /* The library doesn't expose line parsing directly,
+               but we can test the full loadpath */
+            line = end + 1;
+        }
+        free(buf);
+    }
+
+    dns_resconf_close(resconf);
+}
+
+/*
+ * Fuzz target 5: hosts file parsing
+ */
+static void fuzz_hosts(const uint8_t *data, size_t size) {
+    struct dns_hosts *hosts;
+    int error;
+
+    if (size > 8192)
+        return;
+
+    hosts = dns_hosts_open(&error);
+    if (!hosts)
+        return;
+
+    /* Similar to resconf - test what we can */
+    dns_hosts_close(hosts);
+}
+
+/*
+ * Fuzz target 6: Packet building/pushing
+ * Test that we can build packets without crashing
+ */
+static void fuzz_packet_build(const uint8_t *data, size_t size) {
+    struct dns_packet *P;
+    char name[256];
+    int error;
+
+    if (size < 4 || size > 512)
+        return;
+
+    P = dns_p_make(512, &error);
+    if (!P)
+        return;
+
+    /* Use input as a domain name to push */
+    size_t namelen = DNS_PP_MIN(size - 1, sizeof(name) - 1);
+    memcpy(name, data + 1, namelen);
+    name[namelen] = '\0';
+
+    /* Try to make it a valid-ish domain name */
+    for (size_t i = 0; i < namelen; i++) {
+        if (name[i] == '\0')
+            name[i] = '.';
+        else if (name[i] < 32 || name[i] > 126)
+            name[i] = 'a';
+    }
+
+    /* Try pushing a question */
+    dns_p_push(P, DNS_S_QD, name, strlen(name), DNS_T_A, DNS_C_IN, 0, NULL);
+
+    free(P);
+}
+
+/*
+ * Main fuzzer entry point
+ */
+int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+    if (size < 2)
+        return 0;
+
+    /* Use first byte to select which fuzzer to run */
+    uint8_t selector = data[0] % 6;
+    data++;
+    size--;
+
+    switch (selector) {
+    case 0:
+        fuzz_packet_parse(data, size);
+        break;
+    case 1:
+        fuzz_domain_name(data, size);
+        break;
+    case 2:
+        fuzz_rr_parsers(data, size);
+        break;
+    case 3:
+        fuzz_resconf(data, size);
+        break;
+    case 4:
+        fuzz_hosts(data, size);
+        break;
+    case 5:
+        fuzz_packet_build(data, size);
+        break;
+    }
+
+    return 0;
+}
diff --git a/regress/validate-rr-parse.sh b/regress/validate-rr-parse.sh
new file mode 100755
index 0000000..1231f3a
--- /dev/null
+++ b/regress/validate-rr-parse.sh
@@ -0,0 +1,130 @@
+#!/bin/sh
+#
+# Validate RR parsing by comparing ./dns output to dig output
+# This fetches real DNS records and compares the parsed output
+#
+
+DNS_CMD="../src/dns"
+PASS=0
+FAIL=0
+
+normalize() {
+    # Remove all whitespace, uppercase hex
+    tr -d ' \t\n' | tr 'a-f' 'A-F'
+}
+
+compare_output() {
+    query="$1"
+    type="$2"
+
+    printf "%-8s %-40s " "$type" "$query"
+
+    # Get dig output (+short gives just RDATA)
+    dig_raw=$(dig @8.8.8.8 "$query" "$type" +short 2>/dev/null | head -1)
+    dig_out=$(echo "$dig_raw" | normalize)
+
+    # Get ./dns output - match lines starting with the query name
+    # Format: "name. TTL IN TYPE RDATA..."
+    dns_raw=$($DNS_CMD send-query 8.8.8.8 -q "$query" -t "$type" 2>&1 | \
+        grep -E "^[a-zA-Z0-9._-]+\. [0-9]+ IN $type " | head -1 | \
+        awk '{for(i=5;i<=NF;i++) printf "%s", (i>5?" ":"") $i; print ""}')
+    dns_out=$(echo "$dns_raw" | normalize)
+
+    if [ -z "$dig_out" ]; then
+        echo "SKIP (no response)"
+        return 0
+    fi
+
+    if [ -z "$dns_out" ]; then
+        echo "FAIL (./dns no response)"
+        FAIL=$((FAIL + 1))
+        return 1
+    fi
+
+    # Compare normalized output
+    if [ "$dig_out" = "$dns_out" ]; then
+        echo "PASS"
+        PASS=$((PASS + 1))
+        return 0
+    else
+        echo "MISMATCH"
+        echo "    dig: $dig_raw"
+        echo "    dns: $dns_raw"
+        FAIL=$((FAIL + 1))
+        return 1
+    fi
+}
+
+# Compare multi-record RRsets (order-independent)
+compare_multi() {
+    query="$1"
+    type="$2"
+
+    printf "%-8s %-40s " "$type" "$query"
+
+    # Get all dig records, sort them
+    dig_all=$(dig @8.8.8.8 "$query" "$type" +short 2>/dev/null | sort)
+    if [ -z "$dig_all" ]; then
+        echo "SKIP (no response)"
+        return 0
+    fi
+
+    # Get all ./dns records, extract RDATA, sort
+    dns_all=$($DNS_CMD send-query 8.8.8.8 -q "$query" -t "$type" 2>&1 | \
+        grep -E "^[a-zA-Z0-9._-]+\. [0-9]+ IN $type " | \
+        awk '{for(i=5;i<=NF;i++) printf "%s", (i>5?" ":"") $i; print ""}' | sort)
+
+    if [ -z "$dns_all" ]; then
+        echo "FAIL (./dns no response)"
+        FAIL=$((FAIL + 1))
+        return 1
+    fi
+
+    # Compare sorted, normalized outputs
+    dig_norm=$(echo "$dig_all" | normalize)
+    dns_norm=$(echo "$dns_all" | normalize)
+
+    if [ "$dig_norm" = "$dns_norm" ]; then
+        echo "PASS"
+        PASS=$((PASS + 1))
+        return 0
+    else
+        echo "MISMATCH"
+        echo "    dig records: $(echo "$dig_all" | wc -l)"
+        echo "    dns records: $(echo "$dns_all" | wc -l)"
+        FAIL=$((FAIL + 1))
+        return 1
+    fi
+}
+
+echo "=============================================="
+echo "Validating RR parsing: ./dns vs dig"
+echo "=============================================="
+echo ""
+
+# CAA
+compare_output "google.com" "CAA"
+compare_output "letsencrypt.org" "CAA"
+
+# HTTPS/SVCB
+compare_output "www.cloudflare.com" "HTTPS"
+compare_output "crypto.cloudflare.com" "HTTPS"
+
+# DNSKEY (may have multiple records - use order-independent compare)
+compare_multi "cloudflare.com" "DNSKEY"
+
+# DS (Delegation Signer)
+compare_output "cloudflare.com" "DS"
+
+# TLSA (DANE)
+compare_output "_25._tcp.mail.ietf.org" "TLSA"
+
+echo ""
+echo "=============================================="
+printf "Results: %d passed, %d failed\n" "$PASS" "$FAIL"
+echo "=============================================="
+
+if [ $FAIL -gt 0 ]; then
+    exit 1
+fi
+exit 0
diff --git a/src/Makefile b/src/Makefile
index 3a97544..fa43dc6 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -17,13 +17,18 @@ ALL_CPPFLAGS = -DDNS_DEBUG -DDNS_MAIN $(CPPFLAGS)
 ALL_CFLAGS   = -std=gnu99 -Wall -Wextra -O2 -g -fstack-protector $(CFLAGS)
 ALL_LIBS     = $(LIBS)
 
-EXE_CC           = $(shell find $$(echo $${PATH} | tr ':' ' ') -maxdepth 1 -name \*mingw32-gcc -o -name gcc-\* | while read GCC; do echo $$($$GCC -v 2>&1 | tail -n1 | cut -d' ' -f3) $$GCC; done | sort -nr | head -n1 | cut -d' ' -f2)
+# Cross-compile for Windows from Unix, or native compile on Windows with MSYS2/MinGW
+ifeq ($(OS),Windows_NT)
+  EXE_CC         = gcc
+else
+  EXE_CC         = $(shell which x86_64-w64-mingw32-gcc i686-w64-mingw32-gcc 2>/dev/null | head -n1)
+endif
 EXE_CPPFLAGS     = $(ALL_CPPFLAGS)
 EXE_CFLAGS       =
 EXE_LIBS         =
 ALL_EXE_CPPFLAGS = $(EXE_CPPFLAGS)
 ALL_EXE_CFLAGS   = -std=gnu99 -Wall -O2 -g $(EXE_CFLAGS)
-ALL_EXE_LIBS     = -lws2_32 -lgdi32 $(EXE_LIBS)
+ALL_EXE_LIBS     = -lws2_32 -lgdi32 -liphlpapi $(EXE_LIBS)
 
 all: dns
 
diff --git a/src/cache.c b/src/cache.c
index 14ceea7..4f892e4 100644
--- a/src/cache.c
+++ b/src/cache.c
@@ -27,7 +27,12 @@
 #include <stdlib.h>	/* malloc(3) free(3) */
 #include <stdio.h>	/* FILE fprintf(3) */
 
-#include <string.h>	/* strcasecmp(3) memset(3) */
+#include <string.h>	/* memset(3) */
+#if _WIN32
+#define strcasecmp _stricmp
+#else
+#include <strings.h>	/* strcasecmp(3) */
+#endif
 
 #include <errno.h>	/* errno */
 
@@ -111,7 +116,10 @@ static struct rrset *cache_find(struct cache *C, const char *name, enum dns_type
 	if ((error = rrset_init(set, name, type)))
 		goto error;
 
-	assert(!RB_INSERT(rrcache, &C->root, set));
+	{
+		struct rrset *collision = RB_INSERT(rrcache, &C->root, set);
+		assert(!collision);
+	}
 
 	return set;
 syerr:
@@ -288,7 +296,11 @@ int cache_dumpfile(struct cache *C, FILE *fp) {
 
 #include <ctype.h>	/* tolower(3) */
 
+#if _WIN32
+#include <getopt.h>	/* getopt(3) */
+#else
 #include <unistd.h>	/* getopt(3) */
+#endif
 
 
 struct {
@@ -309,7 +321,8 @@ static struct dns_resolv_conf *resconf(void) {
 	int error;
 
 	if (!MAIN.resconf) {
-		assert(MAIN.resconf = dns_resconf_local(&error));
+		MAIN.resconf = dns_resconf_local(&error);
+		assert(MAIN.resconf);
 
 		MAIN.resconf->lookup[2] = MAIN.resconf->lookup[1];
 		MAIN.resconf->lookup[1] = MAIN.resconf->lookup[0];
@@ -323,8 +336,10 @@ static struct dns_resolv_conf *resconf(void) {
 static struct dns_hosts *hosts(void) {
 	int error;
 
-	if (!MAIN.hosts)
-		assert(MAIN.hosts = dns_hosts_local(&error));
+	if (!MAIN.hosts) {
+		MAIN.hosts = dns_hosts_local(&error);
+		assert(MAIN.hosts);
+	}
 
 	return MAIN.hosts;
 } /* hosts() */
@@ -333,8 +348,10 @@ static struct dns_hosts *hosts(void) {
 static struct dns_hints *hints(void) {
 	int error;
 
-	if (!MAIN.hints)
-		assert(MAIN.hints = dns_hints_local(resconf(), &error));
+	if (!MAIN.hints) {
+		MAIN.hints = dns_hints_local(resconf(), &error);
+		assert(MAIN.hints);
+	}
 
 	return MAIN.hints;
 } /* hints() */
@@ -344,8 +361,10 @@ static struct cache *cache(void) {
 	int error;
 
 	if (!MAIN.cache) {
-		assert(MAIN.cache = cache_open(&error));
-		assert(!cache_loadfile(MAIN.cache, stdin, MAIN.origin, MAIN.ttl));
+		MAIN.cache = cache_open(&error);
+		assert(MAIN.cache);
+		error = cache_loadfile(MAIN.cache, stdin, MAIN.origin, MAIN.ttl);
+		assert(!error);
 	}
 
 	return MAIN.cache;
@@ -443,20 +462,26 @@ int main(int argc, char **argv) {
 
 	if (argc > 0)
 		qname = argv[0];
-	if (argc > 1)
-		assert(qtype = dns_itype(argv[1]));
+	if (argc > 1) {
+		qtype = dns_itype(argv[1]);
+		assert(qtype);
+	}
 
 	if (qname) {
-		assert(res = dns_res_open(resconf(), hosts(), hints(), cache_resi(cache()), dns_opts(), &error));
+		res = dns_res_open(resconf(), hosts(), hints(), cache_resi(cache()), dns_opts(), &error);
+		assert(res);
 
-		assert(!dns_res_submit(res, qname, qtype, DNS_C_IN));
+		error = dns_res_submit(res, qname, qtype, DNS_C_IN);
+		assert(!error);
 
 		while ((error = dns_res_check(res))) {
 			assert(error == EAGAIN);
-			assert(!dns_res_poll(res, 5));
+			error = dns_res_poll(res, 5);
+			assert(!error);
 		}
 
-		assert((ans = dns_res_fetch(res, &error)));
+		ans = dns_res_fetch(res, &error);
+		assert(ans);
 
 		cache_showpkt(ans, stdout);
 
diff --git a/src/dns.c b/src/dns.c
index 15ff335..0a82c68 100644
--- a/src/dns.c
+++ b/src/dns.c
@@ -31,6 +31,9 @@
 #undef _BSD_SOURCE
 #define _BSD_SOURCE
 
+#undef _DEFAULT_SOURCE
+#define _DEFAULT_SOURCE
+
 #undef _DARWIN_C_SOURCE
 #define _DARWIN_C_SOURCE
 
@@ -40,18 +43,18 @@
 
 #include <limits.h>		/* INT_MAX */
 #include <stddef.h>		/* offsetof() */
-#ifdef _WIN32
-#define uint32_t unsigned int
-#else
-#include <stdint.h>		/* uint32_t */
-#endif
+#include <stdint.h>		/* uint8_t uint16_t uint32_t */
 #include <stdlib.h>		/* malloc(3) realloc(3) free(3) rand(3) random(3) arc4random(3) */
 #include <stdio.h>		/* FILE fopen(3) fclose(3) getc(3) rewind(3) */
 #include <string.h>		/* memcpy(3) strlen(3) memmove(3) memchr(3) memcmp(3) strchr(3) strsep(3) strcspn(3) */
+#ifndef _WIN32
 #include <strings.h>		/* strcasecmp(3) strncasecmp(3) */
+#endif
 #include <ctype.h>		/* isspace(3) isdigit(3) */
 #include <time.h>		/* time_t time(2) difftime(3) */
+#ifndef _WIN32
 #include <signal.h>		/* SIGPIPE sigemptyset(3) sigaddset(3) sigpending(2) sigprocmask(2) pthread_sigmask(3) sigtimedwait(2) */
+#endif
 #include <errno.h>		/* errno EINVAL ENOENT */
 #undef NDEBUG
 #include <assert.h>		/* assert(3) */
@@ -62,7 +65,21 @@
 #endif
 #include <winsock2.h>
 #include <ws2tcpip.h>
+#include <iphlpapi.h>		/* GetNetworkParams FIXED_INFO */
+#pragma comment(lib, "IPHLPAPI.lib")
+#ifndef AI_NUMERICSERV
+#define AI_NUMERICSERV 0x0400
+#endif
+#ifndef EAI_OVERFLOW
+#define EAI_OVERFLOW WSAENAMETOOLONG
+#endif
+#if defined _MSC_VER
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
 #else
+#include <sys/types.h>	/* ssize_t for mingw */
+#endif
+#else /* !_WIN32 */
 #include <sys/types.h>		/* FD_SETSIZE socklen_t */
 #include <sys/select.h>		/* FD_ZERO FD_SET fd_set select(2) */
 #include <sys/socket.h>		/* AF_INET AF_INET6 AF_UNIX struct sockaddr struct sockaddr_in struct sockaddr_in6 socket(2) */
@@ -79,6 +96,11 @@
 
 #include "dns.h"
 
+/* Suppress -Woverride-init warnings for designated initializer overrides.
+ * This is intentional C behavior used for default+override patterns. */
+#if (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) || __GNUC__ > 4
+#pragma GCC diagnostic ignored "-Woverride-init"
+#endif
 
 /*
  * C O M P I L E R  V E R S I O N  &  F E A T U R E  D E T E C T I O N
@@ -135,6 +157,15 @@
 #define DNS_NORETURN
 #endif
 
+/* Fallthrough annotation for switch statement state machines */
+#if DNS_GNUC_PREREQ(7,0,0)
+#define DNS_FALLTHROUGH __attribute__((fallthrough))
+#elif defined __clang__ && __clang_major__ >= 10
+#define DNS_FALLTHROUGH __attribute__((fallthrough))
+#else
+#define DNS_FALLTHROUGH ((void)0)
+#endif
+
 #if __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
@@ -182,7 +213,7 @@
  *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-#if _WIN32 || _WIN64
+#if defined _MSC_VER
 #define PRIuZ "Iu"
 #else
 #define PRIuZ "zu"
@@ -205,8 +236,10 @@
 #ifndef HAVE_STATIC_ASSERT
 #if DNS_GNUC_PREREQ(0,0,0) && !DNS_GNUC_PREREQ(4,6,0)
 #define HAVE_STATIC_ASSERT 0 /* glibc doesn't check GCC version */
+#elif defined static_assert
+#define HAVE_STATIC_ASSERT 1
 #else
-#define HAVE_STATIC_ASSERT (defined static_assert)
+#define HAVE_STATIC_ASSERT 0
 #endif
 #endif
 
@@ -372,7 +405,11 @@ const char *dns_strerror(int error) {
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #ifndef HAVE___ATOMIC_FETCH_ADD
-#define HAVE___ATOMIC_FETCH_ADD (defined __ATOMIC_RELAXED)
+#ifdef __ATOMIC_RELAXED
+#define HAVE___ATOMIC_FETCH_ADD 1
+#else
+#define HAVE___ATOMIC_FETCH_ADD 0
+#endif
 #endif
 
 #ifndef HAVE___ATOMIC_FETCH_SUB
@@ -382,6 +419,8 @@ const char *dns_strerror(int error) {
 #ifndef DNS_ATOMIC_FETCH_ADD
 #if HAVE___ATOMIC_FETCH_ADD && __GCC_ATOMIC_LONG_LOCK_FREE == 2
 #define DNS_ATOMIC_FETCH_ADD(i) __atomic_fetch_add((i), 1, __ATOMIC_RELAXED)
+#elif _WIN32
+#define DNS_ATOMIC_FETCH_ADD(i) InterlockedExchangeAdd((long *)(i), 1)
 #else
 #pragma message("no atomic_fetch_add available")
 #define DNS_ATOMIC_FETCH_ADD(i) ((*(i))++)
@@ -391,6 +430,8 @@ const char *dns_strerror(int error) {
 #ifndef DNS_ATOMIC_FETCH_SUB
 #if HAVE___ATOMIC_FETCH_SUB && __GCC_ATOMIC_LONG_LOCK_FREE == 2
 #define DNS_ATOMIC_FETCH_SUB(i) __atomic_fetch_sub((i), 1, __ATOMIC_RELAXED)
+#elif _WIN32
+#define DNS_ATOMIC_FETCH_SUB(i) InterlockedExchangeAdd((long *)(i), -1)
 #else
 #pragma message("no atomic_fetch_sub available")
 #define DNS_ATOMIC_FETCH_SUB(i) ((*(i))--)
@@ -423,8 +464,12 @@ static inline unsigned dns_atomic_fetch_sub(dns_atomic_t *i) {
  || defined(__NetBSD__)		\
  || defined(__APPLE__)
 #define DNS_RANDOM	arc4random
-#elif __linux
-#define DNS_RANDOM	random
+#elif _WIN32
+#define DNS_RANDOM	RtlGenRandom
+#elif defined(HAVE_GETRANDOM) || defined(__linux__)
+#define DNS_RANDOM	getrandom
+#elif defined(HAVE_GETENTROPY)
+#define DNS_RANDOM	getentropy
 #else
 #define DNS_RANDOM	rand
 #endif
@@ -434,25 +479,56 @@ static inline unsigned dns_atomic_fetch_sub(dns_atomic_t *i) {
 #define DNS_RANDOM_random	2
 #define DNS_RANDOM_rand		3
 #define DNS_RANDOM_RAND_bytes	4
+#define DNS_RANDOM_getrandom	5
+#define DNS_RANDOM_getentropy	6
+#define DNS_RANDOM_RtlGenRandom	7
 
 #define DNS_RANDOM_OPENSSL	(DNS_RANDOM_RAND_bytes == DNS_PP_XPASTE(DNS_RANDOM_, DNS_RANDOM))
+#define DNS_RANDOM_SYSRANDOM	(DNS_RANDOM_getrandom == DNS_PP_XPASTE(DNS_RANDOM_, DNS_RANDOM) || \
+				 DNS_RANDOM_getentropy == DNS_PP_XPASTE(DNS_RANDOM_, DNS_RANDOM) || \
+				 DNS_RANDOM_RtlGenRandom == DNS_PP_XPASTE(DNS_RANDOM_, DNS_RANDOM))
 
 #if DNS_RANDOM_OPENSSL
 #include <openssl/rand.h>
 #endif
 
+#if DNS_RANDOM_getrandom == DNS_PP_XPASTE(DNS_RANDOM_, DNS_RANDOM)
+#include <sys/random.h>
+#endif
+
+#if _WIN32
+#include <ntsecapi.h>
+#endif
+
 static unsigned dns_random_(void) {
-#if DNS_RANDOM_OPENSSL
 	unsigned r;
+#if DNS_RANDOM_OPENSSL
 	_Bool ok;
 
 	ok = (1 == RAND_bytes((unsigned char *)&r, sizeof r));
 	assert(ok && "1 == RAND_bytes()");
-
-	return r;
+#elif DNS_RANDOM_getrandom == DNS_PP_XPASTE(DNS_RANDOM_, DNS_RANDOM)
+	ssize_t n;
+
+	n = getrandom(&r, sizeof r, 0);
+	assert(n == sizeof r && "getrandom()");
+	(void)n;
+#elif DNS_RANDOM_getentropy == DNS_PP_XPASTE(DNS_RANDOM_, DNS_RANDOM)
+	int ret;
+
+	ret = getentropy(&r, sizeof r);
+	assert(ret == 0 && "getentropy()");
+	(void)ret;
+#elif _WIN32
+	BOOLEAN ok;
+
+	ok = RtlGenRandom(&r, sizeof r);
+	assert(ok && "RtlGenRandom()");
+	(void)ok;
 #else
-	return DNS_RANDOM();
+	r = DNS_RANDOM();
 #endif
+	return r;
 } /* dns_random_() */
 
 dns_random_f **dns_random_p(void) {
@@ -779,7 +855,11 @@ DNS_NOTUSED static size_t dns_strnlcpy(char *dst, size_t lim, const char *src, s
 } /* dns_strnlcpy() */
 
 
-#define DNS_HAVE_SOCKADDR_UN (defined AF_UNIX && !defined _WIN32)
+#if defined AF_UNIX && !defined _WIN32
+#define DNS_HAVE_SOCKADDR_UN 1
+#else
+#define DNS_HAVE_SOCKADDR_UN 0
+#endif
 
 static size_t dns_af_len(int af) {
 	static const size_t table[AF_MAX]	= {
@@ -1086,12 +1166,15 @@ static inline _Bool dns_isspace(unsigned char c) {
 
 
 static int dns_poll(int fd, short events, int timeout) {
-	fd_set rset, wset;
-
 	if (!events)
 		return 0;
 
-	assert(fd >= 0 && (unsigned)fd < FD_SETSIZE);
+#if _WIN32
+	/*
+	 * Windows: use select() since WSAPoll has issues with certain socket states.
+	 * Note: timeout is in seconds for this internal API.
+	 */
+	fd_set rset, wset;
 
 	FD_ZERO(&rset);
 	FD_ZERO(&wset);
@@ -1103,6 +1186,24 @@ static int dns_poll(int fd, short events, int timeout) {
 		FD_SET(fd, &wset);
 
 	select(fd + 1, &rset, &wset, 0, (timeout >= 0)? &(struct timeval){ timeout, 0 } : NULL);
+#else
+	/*
+	 * Unix: use poll() for better scalability (no FD_SETSIZE limit).
+	 */
+	struct pollfd pfd;
+
+	pfd.fd = fd;
+	pfd.events = 0;
+	pfd.revents = 0;
+
+	if (events & DNS_POLLIN)
+		pfd.events |= POLLIN;
+
+	if (events & DNS_POLLOUT)
+		pfd.events |= POLLOUT;
+
+	poll(&pfd, 1, (timeout >= 0) ? timeout * 1000 : -1);
+#endif
 
 	return 0;
 } /* dns_poll() */
@@ -1575,8 +1676,10 @@ struct dns_packet *dns_p_make(size_t len, int *error) {
 	struct dns_packet *P;
 	size_t size = dns_p_calcsize(len);
 
-	if (!(P = dns_p_init(malloc(size), size)))
-		*error = dns_syerr();
+	if (!(P = dns_p_init(malloc(size), size))) {
+		if (error)
+			*error = dns_syerr();
+	}
 
 	return P;
 } /* dns_p_make() */
@@ -1875,6 +1978,8 @@ static void dns_p_dump3(struct dns_packet *P, struct dns_rr_i *I, FILE *fp) {
 	fprintf(fp, ";;     tc : %s(%d)\n", (dns_header(P)->tc)? "TRUNCATED" : "NOT-TRUNCATED", dns_header(P)->tc);
 	fprintf(fp, ";;     rd : %s(%d)\n", (dns_header(P)->rd)? "RECURSION-DESIRED" : "RECURSION-NOT-DESIRED", dns_header(P)->rd);
 	fprintf(fp, ";;     ra : %s(%d)\n", (dns_header(P)->ra)? "RECURSION-ALLOWED" : "RECURSION-NOT-ALLOWED", dns_header(P)->ra);
+	fprintf(fp, ";;     ad : %s(%d)\n", (dns_header(P)->ad)? "AUTHENTICATED" : "NOT-AUTHENTICATED", dns_header(P)->ad);
+	fprintf(fp, ";;     cd : %s(%d)\n", (dns_header(P)->cd)? "CHECKING-DISABLED" : "CHECKING-ENABLED", dns_header(P)->cd);
 	fprintf(fp, ";;  rcode : %s(%d)\n", dns_strrcode(dns_p_rcode(P)), dns_p_rcode(P));
 
 	section	= 0;
@@ -1970,6 +2075,8 @@ enum dns_rcode dns_p_rcode(struct dns_packet *P) {
 
 #define DNS_Q_RD    0x1 /* recursion desired */
 #define DNS_Q_EDNS0 0x2 /* include OPT RR */
+#define DNS_Q_AD    0x4 /* RFC 4035: request authenticated data */
+#define DNS_Q_CD    0x8 /* RFC 4035: disable DNSSEC validation */
 
 static dns_error_t
 dns_q_make2(struct dns_packet **_Q, const char *qname, size_t qlen, enum dns_type qtype, enum dns_class qclass, int qflags)
@@ -1987,6 +2094,8 @@ dns_q_make2(struct dns_packet **_Q, const char *qname, size_t qlen, enum dns_typ
 		goto error;
 
 	dns_header(Q)->rd = !!(qflags & DNS_Q_RD);
+	dns_header(Q)->ad = !!(qflags & DNS_Q_AD);
+	dns_header(Q)->cd = !!(qflags & DNS_Q_CD);
 
 	if (qflags & DNS_Q_EDNS0) {
 		struct dns_opt opt = DNS_OPT_INIT(&opt);
@@ -2548,10 +2657,10 @@ int dns_rr_parse(struct dns_rr *rr, unsigned short src, struct dns_packet *P) {
 	if (P->end - p < 4)
 		goto invalid;
 
-	rr->ttl = ((0xff & P->data[p + 0]) << 24)
-	        | ((0xff & P->data[p + 1]) << 16)
-	        | ((0xff & P->data[p + 2]) << 8)
-	        | ((0xff & P->data[p + 3]) << 0);
+	rr->ttl = ((unsigned)(0xff & P->data[p + 0]) << 24)
+	        | ((unsigned)(0xff & P->data[p + 1]) << 16)
+	        | ((unsigned)(0xff & P->data[p + 2]) << 8)
+	        | ((unsigned)(0xff & P->data[p + 3]) << 0);
 	if (rr->type != DNS_T_OPT)
 		rr->ttl = DNS_PP_MIN(rr->ttl, 0x7fffffffU);
 
@@ -2812,6 +2921,9 @@ static unsigned short dns_rr_i_skip(unsigned short rp, struct dns_rr_i *i, struc
 
 	r0.section = dns_rr_section(rp, P);
 
+	if (!i->sort)
+		return P->end;
+
 	rp = (i->sort == &dns_rr_i_packet)? dns_rr_skip(rp, P) : 12;
 
 	for (; rp < P->end; rp = dns_rr_skip(rp, P)) {
@@ -3582,6 +3694,7 @@ struct dns_opt *dns_opt_init(struct dns_opt *opt, size_t size) {
 
 	opt->rcode   = 0;
 	opt->version = 0;
+	opt->flags   = 0;
 	opt->maxudp  = 0;
 
 	return opt;
@@ -3720,9 +3833,14 @@ size_t dns_ptr_cname(void *dst, size_t lim, struct dns_ptr *ptr) {
 
 
 int dns_sshfp_parse(struct dns_sshfp *fp, struct dns_rr *rr, struct dns_packet *P) {
-	unsigned p = rr->rd.p, pe = rr->rd.p + rr->rd.len;
+	unsigned p = rr->rd.p, pe;
 
-	if (pe - p < 2)
+	/* Validate RDATA bounds against packet */
+	if (rr->rd.len > P->end - rr->rd.p)
+		return DNS_EILLEGAL;
+	pe = rr->rd.p + rr->rd.len;
+
+	if (rr->rd.len < 2)
 		return DNS_EILLEGAL;
 
 	fp->algo = P->data[p++];
@@ -3803,22 +3921,1151 @@ size_t dns_sshfp_print(void *_dst, size_t lim, struct dns_sshfp *fp) {
 	dns_b_fmtju(&dst, fp->type, 0);
 	dns_b_putc(&dst, ' ');
 
-	switch (fp->type) {
-	case DNS_SSHFP_SHA1:
-		for (i = 0; i < sizeof fp->digest.sha1; i++) {
-			dns_b_putc(&dst, hex[0x0f & (fp->digest.sha1[i] >> 4)]);
-			dns_b_putc(&dst, hex[0x0f & (fp->digest.sha1[i] >> 0)]);
+	switch (fp->type) {
+	case DNS_SSHFP_SHA1:
+		for (i = 0; i < sizeof fp->digest.sha1; i++) {
+			dns_b_putc(&dst, hex[0x0f & (fp->digest.sha1[i] >> 4)]);
+			dns_b_putc(&dst, hex[0x0f & (fp->digest.sha1[i] >> 0)]);
+		}
+
+		break;
+	default:
+		dns_b_putc(&dst, '0');
+
+		break;
+	} /* switch() */
+
+	return dns_b_strllen(&dst);
+} /* dns_sshfp_print() */
+
+
+/*
+ * D S  R E S O U R C E  R E C O R D
+ */
+
+int dns_ds_parse(struct dns_ds *ds, struct dns_rr *rr, struct dns_packet *P) {
+	unsigned p = rr->rd.p, pe;
+
+	/* Validate RDATA bounds against packet */
+	if (rr->rd.len > P->end - rr->rd.p)
+		return DNS_EILLEGAL;
+	pe = rr->rd.p + rr->rd.len;
+
+	if (rr->rd.len < 4)
+		return DNS_EILLEGAL;
+
+	ds->keytag = ((unsigned)P->data[p] << 8) | P->data[p+1];
+	p += 2;
+	ds->algorithm = P->data[p++];
+	ds->digtype = P->data[p++];
+
+	ds->digestlen = pe - p;
+	if (ds->digestlen > sizeof ds->digest)
+		ds->digestlen = sizeof ds->digest;
+	memcpy(ds->digest, &P->data[p], ds->digestlen);
+
+	return 0;
+} /* dns_ds_parse() */
+
+
+int dns_ds_push(struct dns_packet *P, struct dns_ds *ds) {
+	unsigned p = P->end, pe = P->size;
+
+	if (pe - p < 4 + ds->digestlen)
+		return DNS_ENOBUFS;
+
+	P->data[p++] = (ds->keytag >> 8) & 0xff;
+	P->data[p++] = ds->keytag & 0xff;
+	P->data[p++] = ds->algorithm;
+	P->data[p++] = ds->digtype;
+	memcpy(&P->data[p], ds->digest, ds->digestlen);
+	p += ds->digestlen;
+
+	P->end = p;
+
+	return 0;
+} /* dns_ds_push() */
+
+
+int dns_ds_cmp(const struct dns_ds *a, const struct dns_ds *b) {
+	int cmp;
+
+	if ((cmp = (int)a->keytag - (int)b->keytag))
+		return cmp;
+	if ((cmp = (int)a->algorithm - (int)b->algorithm))
+		return cmp;
+	if ((cmp = (int)a->digtype - (int)b->digtype))
+		return cmp;
+	if ((cmp = (int)a->digestlen - (int)b->digestlen))
+		return cmp;
+
+	return memcmp(a->digest, b->digest, a->digestlen);
+} /* dns_ds_cmp() */
+
+
+size_t dns_ds_print(void *_dst, size_t lim, struct dns_ds *ds) {
+	static const unsigned char hex[16] = "0123456789ABCDEF";
+	struct dns_buf dst = DNS_B_INTO(_dst, lim);
+	size_t i;
+
+	dns_b_fmtju(&dst, ds->keytag, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_fmtju(&dst, ds->algorithm, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_fmtju(&dst, ds->digtype, 0);
+	dns_b_putc(&dst, ' ');
+
+	for (i = 0; i < ds->digestlen; i++) {
+		dns_b_putc(&dst, hex[0x0f & (ds->digest[i] >> 4)]);
+		dns_b_putc(&dst, hex[0x0f & (ds->digest[i] >> 0)]);
+	}
+
+	return dns_b_strllen(&dst);
+} /* dns_ds_print() */
+
+
+/*
+ * D N S K E Y  R E S O U R C E  R E C O R D
+ */
+
+int dns_dnskey_parse(struct dns_dnskey *key, struct dns_rr *rr, struct dns_packet *P) {
+	unsigned p = rr->rd.p, pe;
+
+	/* Validate RDATA bounds against packet */
+	if (rr->rd.len > P->end - rr->rd.p)
+		return DNS_EILLEGAL;
+	pe = rr->rd.p + rr->rd.len;
+
+	if (rr->rd.len < 4)
+		return DNS_EILLEGAL;
+
+	key->flags = ((unsigned)P->data[p] << 8) | P->data[p+1];
+	p += 2;
+	key->protocol = P->data[p++];
+	key->algorithm = P->data[p++];
+
+	key->pubkeylen = pe - p;
+	if (key->pubkeylen > sizeof key->pubkey)
+		key->pubkeylen = sizeof key->pubkey;
+	memcpy(key->pubkey, &P->data[p], key->pubkeylen);
+
+	return 0;
+} /* dns_dnskey_parse() */
+
+
+int dns_dnskey_push(struct dns_packet *P, struct dns_dnskey *key) {
+	unsigned p = P->end, pe = P->size;
+
+	if (pe - p < 4 + key->pubkeylen)
+		return DNS_ENOBUFS;
+
+	P->data[p++] = (key->flags >> 8) & 0xff;
+	P->data[p++] = key->flags & 0xff;
+	P->data[p++] = key->protocol;
+	P->data[p++] = key->algorithm;
+	memcpy(&P->data[p], key->pubkey, key->pubkeylen);
+	p += key->pubkeylen;
+
+	P->end = p;
+
+	return 0;
+} /* dns_dnskey_push() */
+
+
+int dns_dnskey_cmp(const struct dns_dnskey *a, const struct dns_dnskey *b) {
+	int cmp;
+
+	if ((cmp = (int)a->flags - (int)b->flags))
+		return cmp;
+	if ((cmp = (int)a->protocol - (int)b->protocol))
+		return cmp;
+	if ((cmp = (int)a->algorithm - (int)b->algorithm))
+		return cmp;
+	if ((cmp = (int)a->pubkeylen - (int)b->pubkeylen))
+		return cmp;
+
+	return memcmp(a->pubkey, b->pubkey, a->pubkeylen);
+} /* dns_dnskey_cmp() */
+
+
+static size_t dns_base64_encode(void *_dst, size_t lim, const unsigned char *src, size_t len) {
+	static const char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	struct dns_buf dst = DNS_B_INTO(_dst, lim);
+	size_t i;
+
+	for (i = 0; i + 2 < len; i += 3) {
+		dns_b_putc(&dst, b64[src[i] >> 2]);
+		dns_b_putc(&dst, b64[((src[i] & 0x03) << 4) | (src[i+1] >> 4)]);
+		dns_b_putc(&dst, b64[((src[i+1] & 0x0f) << 2) | (src[i+2] >> 6)]);
+		dns_b_putc(&dst, b64[src[i+2] & 0x3f]);
+	}
+
+	if (i < len) {
+		dns_b_putc(&dst, b64[src[i] >> 2]);
+		if (i + 1 < len) {
+			dns_b_putc(&dst, b64[((src[i] & 0x03) << 4) | (src[i+1] >> 4)]);
+			dns_b_putc(&dst, b64[(src[i+1] & 0x0f) << 2]);
+		} else {
+			dns_b_putc(&dst, b64[(src[i] & 0x03) << 4]);
+			dns_b_putc(&dst, '=');
+		}
+		dns_b_putc(&dst, '=');
+	}
+
+	return dns_b_strllen(&dst);
+} /* dns_base64_encode() */
+
+
+size_t dns_dnskey_print(void *_dst, size_t lim, struct dns_dnskey *key) {
+	struct dns_buf dst = DNS_B_INTO(_dst, lim);
+	char b64buf[4096];
+	size_t b64len;
+
+	dns_b_fmtju(&dst, key->flags, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_fmtju(&dst, key->protocol, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_fmtju(&dst, key->algorithm, 0);
+	dns_b_putc(&dst, ' ');
+
+	b64len = dns_base64_encode(b64buf, sizeof b64buf, key->pubkey, key->pubkeylen);
+	dns_b_put(&dst, b64buf, DNS_PP_MIN(b64len, sizeof b64buf - 1));
+
+	return dns_b_strllen(&dst);
+} /* dns_dnskey_print() */
+
+
+/*
+ * R R S I G  R E S O U R C E  R E C O R D
+ */
+
+int dns_rrsig_parse(struct dns_rrsig *sig, struct dns_rr *rr, struct dns_packet *P) {
+	unsigned p = rr->rd.p, pe;
+	int error;
+
+	/* Validate RDATA bounds against packet */
+	if (rr->rd.len > P->end - rr->rd.p)
+		return DNS_EILLEGAL;
+	pe = rr->rd.p + rr->rd.len;
+
+	if (rr->rd.len < 18)
+		return DNS_EILLEGAL;
+
+	sig->covered = ((unsigned)P->data[p] << 8) | P->data[p+1];
+	p += 2;
+	sig->algorithm = P->data[p++];
+	sig->labels = P->data[p++];
+	sig->origttl = ((uint32_t)P->data[p] << 24) | ((uint32_t)P->data[p+1] << 16) |
+	               ((uint32_t)P->data[p+2] << 8) | P->data[p+3];
+	p += 4;
+	sig->expiration = ((uint32_t)P->data[p] << 24) | ((uint32_t)P->data[p+1] << 16) |
+	                  ((uint32_t)P->data[p+2] << 8) | P->data[p+3];
+	p += 4;
+	sig->inception = ((uint32_t)P->data[p] << 24) | ((uint32_t)P->data[p+1] << 16) |
+	                 ((uint32_t)P->data[p+2] << 8) | P->data[p+3];
+	p += 4;
+	sig->keytag = ((unsigned)P->data[p] << 8) | P->data[p+1];
+	p += 2;
+
+	/* Parse signer name */
+	if (!dns_d_expand(sig->signer, sizeof sig->signer, p, P, &error))
+		return error;
+	p = dns_d_skip(p, P);
+
+	/* Validate p is within RDATA bounds (check for underflow from skip too) */
+	if (p < rr->rd.p || p > pe)
+		return DNS_EILLEGAL;
+
+	/* Copy signature */
+	sig->siglen = pe - p;
+	if (sig->siglen > sizeof sig->signature)
+		sig->siglen = sizeof sig->signature;
+	memcpy(sig->signature, &P->data[p], sig->siglen);
+
+	return 0;
+} /* dns_rrsig_parse() */
+
+
+int dns_rrsig_push(struct dns_packet *P, struct dns_rrsig *sig) {
+	unsigned p = P->end, pe = P->size;
+	int error;
+
+	if (pe - p < 18)
+		return DNS_ENOBUFS;
+
+	P->data[p++] = (sig->covered >> 8) & 0xff;
+	P->data[p++] = sig->covered & 0xff;
+	P->data[p++] = sig->algorithm;
+	P->data[p++] = sig->labels;
+	P->data[p++] = (sig->origttl >> 24) & 0xff;
+	P->data[p++] = (sig->origttl >> 16) & 0xff;
+	P->data[p++] = (sig->origttl >> 8) & 0xff;
+	P->data[p++] = sig->origttl & 0xff;
+	P->data[p++] = (sig->expiration >> 24) & 0xff;
+	P->data[p++] = (sig->expiration >> 16) & 0xff;
+	P->data[p++] = (sig->expiration >> 8) & 0xff;
+	P->data[p++] = sig->expiration & 0xff;
+	P->data[p++] = (sig->inception >> 24) & 0xff;
+	P->data[p++] = (sig->inception >> 16) & 0xff;
+	P->data[p++] = (sig->inception >> 8) & 0xff;
+	P->data[p++] = sig->inception & 0xff;
+	P->data[p++] = (sig->keytag >> 8) & 0xff;
+	P->data[p++] = sig->keytag & 0xff;
+
+	P->end = p;
+
+	/* Push signer name */
+	if ((error = dns_d_push(P, sig->signer, strlen(sig->signer))))
+		return error;
+	p = P->end;
+
+	/* Push signature */
+	if (pe - p < sig->siglen)
+		return DNS_ENOBUFS;
+	memcpy(&P->data[p], sig->signature, sig->siglen);
+	P->end = p + sig->siglen;
+
+	return 0;
+} /* dns_rrsig_push() */
+
+
+int dns_rrsig_cmp(const struct dns_rrsig *a, const struct dns_rrsig *b) {
+	int cmp;
+
+	if ((cmp = (int)a->covered - (int)b->covered))
+		return cmp;
+	if ((cmp = (int)a->algorithm - (int)b->algorithm))
+		return cmp;
+	if ((cmp = (int)a->labels - (int)b->labels))
+		return cmp;
+	if ((cmp = strcasecmp(a->signer, b->signer)))
+		return cmp;
+	if ((cmp = (int)a->keytag - (int)b->keytag))
+		return cmp;
+
+	return 0;
+} /* dns_rrsig_cmp() */
+
+
+size_t dns_rrsig_print(void *_dst, size_t lim, struct dns_rrsig *sig) {
+	struct dns_buf dst = DNS_B_INTO(_dst, lim);
+	char b64buf[4096];
+	size_t b64len;
+
+	/* Type covered */
+	dns_b_puts(&dst, dns_strtype(sig->covered));
+	dns_b_putc(&dst, ' ');
+	dns_b_fmtju(&dst, sig->algorithm, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_fmtju(&dst, sig->labels, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_fmtju(&dst, sig->origttl, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_fmtju(&dst, sig->expiration, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_fmtju(&dst, sig->inception, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_fmtju(&dst, sig->keytag, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_puts(&dst, sig->signer);
+	dns_b_putc(&dst, ' ');
+
+	b64len = dns_base64_encode(b64buf, sizeof b64buf, sig->signature, sig->siglen);
+	dns_b_put(&dst, b64buf, DNS_PP_MIN(b64len, sizeof b64buf - 1));
+
+	return dns_b_strllen(&dst);
+} /* dns_rrsig_print() */
+
+
+/*
+ * N S E C  R E S O U R C E  R E C O R D
+ */
+
+int dns_nsec_parse(struct dns_nsec *nsec, struct dns_rr *rr, struct dns_packet *P) {
+	unsigned p = rr->rd.p;
+	int error;
+
+	/* Validate RDATA bounds against packet */
+	if (rr->rd.len > P->end - rr->rd.p)
+		return DNS_EILLEGAL;
+
+	/* Parse next domain name */
+	if (!dns_d_expand(nsec->next, sizeof nsec->next, p, P, &error))
+		return error;
+	p = dns_d_skip(p, P);
+
+	/* Validate p is within RDATA bounds (check for overflow too) */
+	if (p < rr->rd.p || p > rr->rd.p + rr->rd.len)
+		return DNS_EILLEGAL;
+
+	/* Copy type bitmap */
+	nsec->typemaplen = (rr->rd.p + rr->rd.len) - p;
+	if (nsec->typemaplen > sizeof nsec->typemap)
+		nsec->typemaplen = sizeof nsec->typemap;
+	memcpy(nsec->typemap, &P->data[p], nsec->typemaplen);
+
+	return 0;
+} /* dns_nsec_parse() */
+
+
+int dns_nsec_push(struct dns_packet *P, struct dns_nsec *nsec) {
+	unsigned p = P->end, pe = P->size;
+	int error;
+
+	/* Push next domain name */
+	if ((error = dns_d_push(P, nsec->next, strlen(nsec->next))))
+		return error;
+	p = P->end;
+
+	/* Push type bitmap */
+	if (pe - p < nsec->typemaplen)
+		return DNS_ENOBUFS;
+	memcpy(&P->data[p], nsec->typemap, nsec->typemaplen);
+	P->end = p + nsec->typemaplen;
+
+	return 0;
+} /* dns_nsec_push() */
+
+
+int dns_nsec_cmp(const struct dns_nsec *a, const struct dns_nsec *b) {
+	return strcasecmp(a->next, b->next);
+} /* dns_nsec_cmp() */
+
+
+_Bool dns_nsec_hastype(const struct dns_nsec *nsec, enum dns_type type) {
+	unsigned window, offset, byte, bit;
+	const unsigned char *p, *pe;
+
+	p = nsec->typemap;
+	pe = p + nsec->typemaplen;
+
+	while (p + 2 <= pe) {
+		window = *p++;
+		offset = *p++;
+		if (p + offset > pe)
+			break;
+
+		if ((unsigned)type >= window * 256 && (unsigned)type < (window + 1) * 256) {
+			unsigned tbit = (unsigned)type - window * 256;
+			byte = tbit / 8;
+			bit = 7 - (tbit % 8);
+			if (byte < offset && (p[byte] & (1 << bit)))
+				return 1;
+		}
+		p += offset;
+	}
+
+	return 0;
+} /* dns_nsec_hastype() */
+
+
+static size_t dns_typemap_print(void *_dst, size_t lim, const unsigned char *typemap, size_t typemaplen) {
+	struct dns_buf dst = DNS_B_INTO(_dst, lim);
+	const unsigned char *p = typemap, *pe = typemap + typemaplen;
+	int first = 1;
+
+	while (p + 2 <= pe) {
+		unsigned window = *p++;
+		unsigned len = *p++;
+		unsigned i, j;
+
+		/* Validate len doesn't exceed remaining buffer */
+		if (len > (size_t)(pe - p))
+			break;
+
+		for (i = 0; i < len; i++) {
+			for (j = 0; j < 8; j++) {
+				if (p[i] & (1 << (7 - j))) {
+					unsigned type = window * 256 + i * 8 + j;
+					if (!first)
+						dns_b_putc(&dst, ' ');
+					first = 0;
+					dns_b_puts(&dst, dns_strtype(type));
+				}
+			}
+		}
+		p += len;
+	}
+
+	return dns_b_strllen(&dst);
+} /* dns_typemap_print() */
+
+
+size_t dns_nsec_print(void *_dst, size_t lim, struct dns_nsec *nsec) {
+	struct dns_buf dst = DNS_B_INTO(_dst, lim);
+	char typebuf[4096];
+	size_t typelen;
+
+	dns_b_puts(&dst, nsec->next);
+	dns_b_putc(&dst, ' ');
+
+	typelen = dns_typemap_print(typebuf, sizeof typebuf, nsec->typemap, nsec->typemaplen);
+	dns_b_put(&dst, typebuf, DNS_PP_MIN(typelen, sizeof typebuf - 1));
+
+	return dns_b_strllen(&dst);
+} /* dns_nsec_print() */
+
+
+/*
+ * N S E C 3  R E S O U R C E  R E C O R D
+ */
+
+int dns_nsec3_parse(struct dns_nsec3 *nsec3, struct dns_rr *rr, struct dns_packet *P) {
+	unsigned p = rr->rd.p, pe;
+
+	/* Validate RDATA bounds against packet */
+	if (rr->rd.len > P->end - rr->rd.p)
+		return DNS_EILLEGAL;
+	pe = rr->rd.p + rr->rd.len;
+
+	if (rr->rd.len < 5)
+		return DNS_EILLEGAL;
+
+	nsec3->algorithm = P->data[p++];
+	nsec3->flags = P->data[p++];
+	nsec3->iterations = ((unsigned)P->data[p] << 8) | P->data[p+1];
+	p += 2;
+
+	/* Salt length and salt */
+	nsec3->saltlen = P->data[p++];
+	if (pe - p < nsec3->saltlen)
+		return DNS_EILLEGAL;
+	if (nsec3->saltlen > sizeof nsec3->salt)
+		return DNS_EILLEGAL;
+	memcpy(nsec3->salt, &P->data[p], nsec3->saltlen);
+	p += nsec3->saltlen;
+
+	/* Hash length and next hashed owner name */
+	if (pe - p < 1)
+		return DNS_EILLEGAL;
+	nsec3->nexthashlen = P->data[p++];
+	if (pe - p < nsec3->nexthashlen)
+		return DNS_EILLEGAL;
+	if (nsec3->nexthashlen > sizeof nsec3->nexthash)
+		return DNS_EILLEGAL;
+	memcpy(nsec3->nexthash, &P->data[p], nsec3->nexthashlen);
+	p += nsec3->nexthashlen;
+
+	/* Type bitmap */
+	nsec3->typemaplen = pe - p;
+	if (nsec3->typemaplen > sizeof nsec3->typemap)
+		nsec3->typemaplen = sizeof nsec3->typemap;
+	memcpy(nsec3->typemap, &P->data[p], nsec3->typemaplen);
+
+	return 0;
+} /* dns_nsec3_parse() */
+
+
+int dns_nsec3_push(struct dns_packet *P, struct dns_nsec3 *nsec3) {
+	unsigned p = P->end, pe = P->size;
+	size_t needed = 5 + nsec3->saltlen + 1 + nsec3->nexthashlen + nsec3->typemaplen;
+
+	if (pe - p < needed)
+		return DNS_ENOBUFS;
+
+	P->data[p++] = nsec3->algorithm;
+	P->data[p++] = nsec3->flags;
+	P->data[p++] = (nsec3->iterations >> 8) & 0xff;
+	P->data[p++] = nsec3->iterations & 0xff;
+	P->data[p++] = nsec3->saltlen;
+	memcpy(&P->data[p], nsec3->salt, nsec3->saltlen);
+	p += nsec3->saltlen;
+	P->data[p++] = nsec3->nexthashlen;
+	memcpy(&P->data[p], nsec3->nexthash, nsec3->nexthashlen);
+	p += nsec3->nexthashlen;
+	memcpy(&P->data[p], nsec3->typemap, nsec3->typemaplen);
+	p += nsec3->typemaplen;
+
+	P->end = p;
+
+	return 0;
+} /* dns_nsec3_push() */
+
+
+int dns_nsec3_cmp(const struct dns_nsec3 *a, const struct dns_nsec3 *b) {
+	int cmp;
+
+	if ((cmp = (int)a->algorithm - (int)b->algorithm))
+		return cmp;
+	if ((cmp = (int)a->nexthashlen - (int)b->nexthashlen))
+		return cmp;
+
+	return memcmp(a->nexthash, b->nexthash, a->nexthashlen);
+} /* dns_nsec3_cmp() */
+
+
+_Bool dns_nsec3_hastype(const struct dns_nsec3 *nsec3, enum dns_type type) {
+	unsigned window, offset, byte, bit;
+	const unsigned char *p, *pe;
+
+	p = nsec3->typemap;
+	pe = p + nsec3->typemaplen;
+
+	while (p + 2 <= pe) {
+		window = *p++;
+		offset = *p++;
+		if (p + offset > pe)
+			break;
+
+		if ((unsigned)type >= window * 256 && (unsigned)type < (window + 1) * 256) {
+			unsigned tbit = (unsigned)type - window * 256;
+			byte = tbit / 8;
+			bit = 7 - (tbit % 8);
+			if (byte < offset && (p[byte] & (1 << bit)))
+				return 1;
+		}
+		p += offset;
+	}
+
+	return 0;
+} /* dns_nsec3_hastype() */
+
+
+static size_t dns_base32hex_encode(void *_dst, size_t lim, const unsigned char *src, size_t len) {
+	static const char b32[] = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+	struct dns_buf dst = DNS_B_INTO(_dst, lim);
+	size_t i;
+	unsigned long acc;
+	int bits;
+
+	acc = 0;
+	bits = 0;
+	for (i = 0; i < len; i++) {
+		acc = (acc << 8) | src[i];
+		bits += 8;
+		while (bits >= 5) {
+			bits -= 5;
+			dns_b_putc(&dst, b32[(acc >> bits) & 0x1f]);
+		}
+	}
+	if (bits > 0) {
+		dns_b_putc(&dst, b32[(acc << (5 - bits)) & 0x1f]);
+	}
+
+	return dns_b_strllen(&dst);
+} /* dns_base32hex_encode() */
+
+
+size_t dns_nsec3_print(void *_dst, size_t lim, struct dns_nsec3 *nsec3) {
+	static const unsigned char hex[16] = "0123456789ABCDEF";
+	struct dns_buf dst = DNS_B_INTO(_dst, lim);
+	char typebuf[4096], hashbuf[256];
+	size_t typelen, hashlen, i;
+
+	dns_b_fmtju(&dst, nsec3->algorithm, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_fmtju(&dst, nsec3->flags, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_fmtju(&dst, nsec3->iterations, 0);
+	dns_b_putc(&dst, ' ');
+
+	/* Salt (hex) or "-" if empty */
+	if (nsec3->saltlen == 0) {
+		dns_b_putc(&dst, '-');
+	} else {
+		for (i = 0; i < nsec3->saltlen; i++) {
+			dns_b_putc(&dst, hex[0x0f & (nsec3->salt[i] >> 4)]);
+			dns_b_putc(&dst, hex[0x0f & (nsec3->salt[i] >> 0)]);
+		}
+	}
+	dns_b_putc(&dst, ' ');
+
+	/* Next hashed owner name (base32hex) */
+	hashlen = dns_base32hex_encode(hashbuf, sizeof hashbuf, nsec3->nexthash, nsec3->nexthashlen);
+	dns_b_put(&dst, hashbuf, DNS_PP_MIN(hashlen, sizeof hashbuf - 1));
+	dns_b_putc(&dst, ' ');
+
+	/* Type bitmap */
+	typelen = dns_typemap_print(typebuf, sizeof typebuf, nsec3->typemap, nsec3->typemaplen);
+	dns_b_put(&dst, typebuf, DNS_PP_MIN(typelen, sizeof typebuf - 1));
+
+	return dns_b_strllen(&dst);
+} /* dns_nsec3_print() */
+
+
+/*
+ * T L S A  R E S O U R C E  R E C O R D
+ */
+
+int dns_tlsa_parse(struct dns_tlsa *tlsa, struct dns_rr *rr, struct dns_packet *P) {
+	unsigned p = rr->rd.p, pe;
+
+	/* Validate RDATA bounds against packet */
+	if (rr->rd.len > P->end - rr->rd.p)
+		return DNS_EILLEGAL;
+	pe = rr->rd.p + rr->rd.len;
+
+	if (rr->rd.len < 3)
+		return DNS_EILLEGAL;
+
+	tlsa->usage = P->data[p++];
+	tlsa->selector = P->data[p++];
+	tlsa->matchtype = P->data[p++];
+
+	tlsa->datalen = pe - p;
+	if (tlsa->datalen > sizeof tlsa->data)
+		tlsa->datalen = sizeof tlsa->data;
+	memcpy(tlsa->data, &P->data[p], tlsa->datalen);
+
+	return 0;
+} /* dns_tlsa_parse() */
+
+
+int dns_tlsa_push(struct dns_packet *P, struct dns_tlsa *tlsa) {
+	unsigned p = P->end, pe = P->size;
+
+	if (pe - p < 3 + tlsa->datalen)
+		return DNS_ENOBUFS;
+
+	P->data[p++] = tlsa->usage;
+	P->data[p++] = tlsa->selector;
+	P->data[p++] = tlsa->matchtype;
+	memcpy(&P->data[p], tlsa->data, tlsa->datalen);
+	p += tlsa->datalen;
+
+	P->end = p;
+
+	return 0;
+} /* dns_tlsa_push() */
+
+
+int dns_tlsa_cmp(const struct dns_tlsa *a, const struct dns_tlsa *b) {
+	int cmp;
+
+	if ((cmp = (int)a->usage - (int)b->usage))
+		return cmp;
+	if ((cmp = (int)a->selector - (int)b->selector))
+		return cmp;
+	if ((cmp = (int)a->matchtype - (int)b->matchtype))
+		return cmp;
+	if ((cmp = (int)a->datalen - (int)b->datalen))
+		return cmp;
+
+	return memcmp(a->data, b->data, a->datalen);
+} /* dns_tlsa_cmp() */
+
+
+size_t dns_tlsa_print(void *_dst, size_t lim, struct dns_tlsa *tlsa) {
+	static const unsigned char hex[16] = "0123456789ABCDEF";
+	struct dns_buf dst = DNS_B_INTO(_dst, lim);
+	size_t i;
+
+	dns_b_fmtju(&dst, tlsa->usage, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_fmtju(&dst, tlsa->selector, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_fmtju(&dst, tlsa->matchtype, 0);
+	dns_b_putc(&dst, ' ');
+
+	for (i = 0; i < tlsa->datalen; i++) {
+		dns_b_putc(&dst, hex[0x0f & (tlsa->data[i] >> 4)]);
+		dns_b_putc(&dst, hex[0x0f & (tlsa->data[i] >> 0)]);
+	}
+
+	return dns_b_strllen(&dst);
+} /* dns_tlsa_print() */
+
+
+/*
+ * C A A  R E S O U R C E  R E C O R D
+ */
+
+int dns_caa_parse(struct dns_caa *caa, struct dns_rr *rr, struct dns_packet *P) {
+	unsigned p = rr->rd.p, pe;
+	size_t taglen;
+
+	/* Validate RDATA bounds against packet */
+	if (rr->rd.len > P->end - rr->rd.p)
+		return DNS_EILLEGAL;
+	pe = rr->rd.p + rr->rd.len;
+
+	if (rr->rd.len < 2)
+		return DNS_EILLEGAL;
+
+	caa->flags = P->data[p++];
+	taglen = P->data[p++];
+
+	if (pe - p < taglen)
+		return DNS_EILLEGAL;
+
+	if (taglen > sizeof caa->tag - 1)
+		taglen = sizeof caa->tag - 1;
+	memcpy(caa->tag, &P->data[p], taglen);
+	caa->tag[taglen] = '\0';
+	p += taglen;
+
+	caa->valuelen = pe - p;
+	if (caa->valuelen > sizeof caa->value - 1)
+		caa->valuelen = sizeof caa->value - 1;
+	memcpy(caa->value, &P->data[p], caa->valuelen);
+	caa->value[caa->valuelen] = '\0';
+
+	return 0;
+} /* dns_caa_parse() */
+
+
+int dns_caa_push(struct dns_packet *P, struct dns_caa *caa) {
+	unsigned p = P->end, pe = P->size;
+	size_t taglen = strlen(caa->tag);
+
+	if (pe - p < 2 + taglen + caa->valuelen)
+		return DNS_ENOBUFS;
+
+	P->data[p++] = caa->flags;
+	P->data[p++] = taglen;
+	memcpy(&P->data[p], caa->tag, taglen);
+	p += taglen;
+	memcpy(&P->data[p], caa->value, caa->valuelen);
+	p += caa->valuelen;
+
+	P->end = p;
+
+	return 0;
+} /* dns_caa_push() */
+
+
+int dns_caa_cmp(const struct dns_caa *a, const struct dns_caa *b) {
+	int cmp;
+
+	if ((cmp = (int)a->flags - (int)b->flags))
+		return cmp;
+	if ((cmp = strcasecmp(a->tag, b->tag)))
+		return cmp;
+	if ((cmp = (int)a->valuelen - (int)b->valuelen))
+		return cmp;
+
+	return memcmp(a->value, b->value, a->valuelen);
+} /* dns_caa_cmp() */
+
+
+size_t dns_caa_print(void *_dst, size_t lim, struct dns_caa *caa) {
+	struct dns_buf dst = DNS_B_INTO(_dst, lim);
+
+	dns_b_fmtju(&dst, caa->flags, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_puts(&dst, caa->tag);
+	dns_b_putc(&dst, ' ');
+	dns_b_putc(&dst, '"');
+	dns_b_put(&dst, caa->value, caa->valuelen);
+	dns_b_putc(&dst, '"');
+
+	return dns_b_strllen(&dst);
+} /* dns_caa_print() */
+
+
+/*
+ * U R I  R E S O U R C E  R E C O R D
+ */
+
+int dns_uri_parse(struct dns_uri *uri, struct dns_rr *rr, struct dns_packet *P) {
+	unsigned p = rr->rd.p, pe;
+	size_t targetlen;
+
+	/* Validate RDATA bounds against packet */
+	if (rr->rd.len > P->end - rr->rd.p)
+		return DNS_EILLEGAL;
+	pe = rr->rd.p + rr->rd.len;
+
+	if (rr->rd.len < 4)
+		return DNS_EILLEGAL;
+
+	uri->priority = ((unsigned)P->data[p] << 8) | P->data[p+1];
+	p += 2;
+	uri->weight = ((unsigned)P->data[p] << 8) | P->data[p+1];
+	p += 2;
+
+	targetlen = pe - p;
+	if (targetlen > sizeof uri->target - 1)
+		targetlen = sizeof uri->target - 1;
+	memcpy(uri->target, &P->data[p], targetlen);
+	uri->target[targetlen] = '\0';
+
+	return 0;
+} /* dns_uri_parse() */
+
+
+int dns_uri_push(struct dns_packet *P, struct dns_uri *uri) {
+	unsigned p = P->end, pe = P->size;
+	size_t targetlen = strlen(uri->target);
+
+	if (pe - p < 4 + targetlen)
+		return DNS_ENOBUFS;
+
+	P->data[p++] = (uri->priority >> 8) & 0xff;
+	P->data[p++] = uri->priority & 0xff;
+	P->data[p++] = (uri->weight >> 8) & 0xff;
+	P->data[p++] = uri->weight & 0xff;
+	memcpy(&P->data[p], uri->target, targetlen);
+	p += targetlen;
+
+	P->end = p;
+
+	return 0;
+} /* dns_uri_push() */
+
+
+int dns_uri_cmp(const struct dns_uri *a, const struct dns_uri *b) {
+	int cmp;
+
+	if ((cmp = (int)a->priority - (int)b->priority))
+		return cmp;
+	if ((cmp = (int)a->weight - (int)b->weight))
+		return cmp;
+
+	return strcmp(a->target, b->target);
+} /* dns_uri_cmp() */
+
+
+size_t dns_uri_print(void *_dst, size_t lim, struct dns_uri *uri) {
+	struct dns_buf dst = DNS_B_INTO(_dst, lim);
+
+	dns_b_fmtju(&dst, uri->priority, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_fmtju(&dst, uri->weight, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_putc(&dst, '"');
+	dns_b_puts(&dst, uri->target);
+	dns_b_putc(&dst, '"');
+
+	return dns_b_strllen(&dst);
+} /* dns_uri_print() */
+
+
+/*
+ * S V C B / H T T P S  R E S O U R C E  R E C O R D
+ */
+
+int dns_svcb_parse(struct dns_svcb *svcb, struct dns_rr *rr, struct dns_packet *P) {
+	unsigned p = rr->rd.p, pe;
+	int error;
+
+	/* Validate RDATA bounds against packet */
+	if (rr->rd.len > P->end - rr->rd.p)
+		return DNS_EILLEGAL;
+	pe = rr->rd.p + rr->rd.len;
+
+	if (rr->rd.len < 2)
+		return DNS_EILLEGAL;
+
+	svcb->priority = ((unsigned)P->data[p] << 8) | P->data[p+1];
+	p += 2;
+
+	/* Parse target name */
+	if (!dns_d_expand(svcb->target, sizeof svcb->target, p, P, &error))
+		return error;
+	p = dns_d_skip(p, P);
+
+	/* Validate p is within RDATA bounds (check for underflow from skip too) */
+	if (p < rr->rd.p || p > pe)
+		return DNS_EILLEGAL;
+
+	/* Copy SvcParams */
+	svcb->paramslen = pe - p;
+	if (svcb->paramslen > sizeof svcb->params)
+		svcb->paramslen = sizeof svcb->params;
+	memcpy(svcb->params, &P->data[p], svcb->paramslen);
+
+	return 0;
+} /* dns_svcb_parse() */
+
+
+int dns_svcb_push(struct dns_packet *P, struct dns_svcb *svcb) {
+	unsigned p = P->end, pe = P->size;
+	int error;
+
+	if (pe - p < 2)
+		return DNS_ENOBUFS;
+
+	P->data[p++] = (svcb->priority >> 8) & 0xff;
+	P->data[p++] = svcb->priority & 0xff;
+
+	P->end = p;
+
+	/* Push target name */
+	if ((error = dns_d_push(P, svcb->target, strlen(svcb->target))))
+		return error;
+	p = P->end;
+
+	/* Push SvcParams */
+	if (pe - p < svcb->paramslen)
+		return DNS_ENOBUFS;
+	memcpy(&P->data[p], svcb->params, svcb->paramslen);
+	P->end = p + svcb->paramslen;
+
+	return 0;
+} /* dns_svcb_push() */
+
+
+int dns_svcb_cmp(const struct dns_svcb *a, const struct dns_svcb *b) {
+	int cmp;
+
+	if ((cmp = (int)a->priority - (int)b->priority))
+		return cmp;
+
+	return strcasecmp(a->target, b->target);
+} /* dns_svcb_cmp() */
+
+
+_Bool dns_svcb_getparam(const struct dns_svcb *svcb, enum dns_svcb_key key, const unsigned char **data, size_t *len) {
+	const unsigned char *p = svcb->params, *pe = p + svcb->paramslen;
+
+	while (p + 4 <= pe) {
+		unsigned pkey = ((unsigned)p[0] << 8) | p[1];
+		unsigned plen = ((unsigned)p[2] << 8) | p[3];
+		p += 4;
+
+		if (p + plen > pe)
+			break;
+
+		if (pkey == (unsigned)key) {
+			*data = p;
+			*len = plen;
+			return 1;
+		}
+		p += plen;
+	}
+
+	return 0;
+} /* dns_svcb_getparam() */
+
+
+static const char *dns_svcb_keyname(unsigned key) {
+	switch (key) {
+	case DNS_SVCB_KEY_MANDATORY: return "mandatory";
+	case DNS_SVCB_KEY_ALPN: return "alpn";
+	case DNS_SVCB_KEY_NO_DEFAULT_ALPN: return "no-default-alpn";
+	case DNS_SVCB_KEY_PORT: return "port";
+	case DNS_SVCB_KEY_IPV4HINT: return "ipv4hint";
+	case DNS_SVCB_KEY_ECH: return "ech";
+	case DNS_SVCB_KEY_IPV6HINT: return "ipv6hint";
+	case DNS_SVCB_KEY_DOHPATH: return "dohpath";
+	case DNS_SVCB_KEY_OHTTP: return "ohttp";
+	default: return NULL;
+	}
+} /* dns_svcb_keyname() */
+
+
+size_t dns_svcb_print(void *_dst, size_t lim, struct dns_svcb *svcb) {
+	struct dns_buf dst = DNS_B_INTO(_dst, lim);
+	const unsigned char *p, *pe;
+	char addrbuf[INET6_ADDRSTRLEN];
+
+	dns_b_fmtju(&dst, svcb->priority, 0);
+	dns_b_putc(&dst, ' ');
+	dns_b_puts(&dst, svcb->target[0] ? svcb->target : ".");
+
+	/* Parse and print SvcParams */
+	p = svcb->params;
+	pe = p + svcb->paramslen;
+
+	while (p + 4 <= pe) {
+		unsigned key = ((unsigned)p[0] << 8) | p[1];
+		unsigned len = ((unsigned)p[2] << 8) | p[3];
+		const char *keyname;
+		p += 4;
+
+		/* Validate len doesn't overflow or exceed remaining buffer */
+		if (len > (size_t)(pe - p))
+			break;
+
+		dns_b_putc(&dst, ' ');
+
+		keyname = dns_svcb_keyname(key);
+		if (keyname) {
+			dns_b_puts(&dst, keyname);
+		} else {
+			dns_b_puts(&dst, "key");
+			dns_b_fmtju(&dst, key, 0);
 		}
 
-		break;
-	default:
-		dns_b_putc(&dst, '0');
-
-		break;
-	} /* switch() */
+		if (len > 0) {
+			dns_b_putc(&dst, '=');
+
+			switch (key) {
+			case DNS_SVCB_KEY_MANDATORY: {
+				const unsigned char *mp = p;
+				int first = 1;
+				while (mp + 2 <= p + len) {
+					unsigned mkey = ((unsigned)mp[0] << 8) | mp[1];
+					const char *mkeyname = dns_svcb_keyname(mkey);
+					if (!first) dns_b_putc(&dst, ',');
+					first = 0;
+					if (mkeyname) {
+						dns_b_puts(&dst, mkeyname);
+					} else {
+						dns_b_puts(&dst, "key");
+						dns_b_fmtju(&dst, mkey, 0);
+					}
+					mp += 2;
+				}
+				break;
+			}
+			case DNS_SVCB_KEY_PORT:
+				if (len >= 2) {
+					unsigned port = ((unsigned)p[0] << 8) | p[1];
+					dns_b_fmtju(&dst, port, 0);
+				}
+				break;
+			case DNS_SVCB_KEY_ALPN: {
+				const unsigned char *ap = p, *ape = p + len;
+				int first = 1;
+				dns_b_putc(&dst, '"');
+				while (ap < ape) {
+					unsigned alen = *ap++;
+					if (ap + alen > ape) break;
+					if (!first) dns_b_putc(&dst, ',');
+					first = 0;
+					dns_b_put(&dst, ap, alen);
+					ap += alen;
+				}
+				dns_b_putc(&dst, '"');
+				break;
+			}
+			case DNS_SVCB_KEY_IPV4HINT: {
+				const unsigned char *ap = p;
+				int first = 1;
+				while (ap + 4 <= p + len) {
+					if (!first) dns_b_putc(&dst, ',');
+					first = 0;
+					if (dns_inet_ntop(AF_INET, ap, addrbuf, sizeof addrbuf))
+						dns_b_puts(&dst, addrbuf);
+					ap += 4;
+				}
+				break;
+			}
+			case DNS_SVCB_KEY_IPV6HINT: {
+				const unsigned char *ap = p;
+				int first = 1;
+				while (ap + 16 <= p + len) {
+					if (!first) dns_b_putc(&dst, ',');
+					first = 0;
+					if (dns_inet_ntop(AF_INET6, ap, addrbuf, sizeof addrbuf))
+						dns_b_puts(&dst, addrbuf);
+					ap += 16;
+				}
+				break;
+			}
+			case DNS_SVCB_KEY_DOHPATH:
+				dns_b_putc(&dst, '"');
+				dns_b_put(&dst, p, len);
+				dns_b_putc(&dst, '"');
+				break;
+			case DNS_SVCB_KEY_ECH:
+			default: {
+				/* Base64 encoding for binary params (like ech) */
+				char b64buf[2048];
+				size_t b64len = dns_base64_encode(b64buf, sizeof(b64buf), p, len);
+				(void)b64len;
+				dns_b_puts(&dst, b64buf);
+				break;
+			}
+			}
+		}
+		p += len;
+	}
 
 	return dns_b_strllen(&dst);
-} /* dns_sshfp_print() */
+} /* dns_svcb_print() */
 
 
 struct dns_txt *dns_txt_init(struct dns_txt *txt, size_t size) {
@@ -3951,29 +5198,48 @@ size_t dns_txt_print(void *_dst, size_t lim, struct dns_txt *txt) {
 } /* dns_txt_print() */
 
 
+typedef int (*dns_rr_parse_f)(void *, struct dns_rr *, struct dns_packet *);
+typedef int (*dns_rr_push_f)(struct dns_packet *, void *);
+typedef int (*dns_rr_cmp_f)(const void *, const void *);
+typedef size_t (*dns_rr_print_f)(void *, size_t, void *);
+typedef size_t (*dns_rr_cname_f)(void *, size_t, void *);
+
 static const struct dns_rrtype {
 	enum dns_type type;
 	const char *name;
 	union dns_any *(*init)(union dns_any *, size_t);
-	int (*parse)();
-	int (*push)();
-	int (*cmp)();
-	size_t (*print)();
-	size_t (*cname)();
+	dns_rr_parse_f parse;
+	dns_rr_push_f push;
+	dns_rr_cmp_f cmp;
+	dns_rr_print_f print;
+	dns_rr_cname_f cname;
 } dns_rrtypes[]	= {
-	{ DNS_T_A,      "A",      0,                 &dns_a_parse,      &dns_a_push,      &dns_a_cmp,      &dns_a_print,      0,                },
-	{ DNS_T_AAAA,   "AAAA",   0,                 &dns_aaaa_parse,   &dns_aaaa_push,   &dns_aaaa_cmp,   &dns_aaaa_print,   0,                },
-	{ DNS_T_MX,     "MX",     0,                 &dns_mx_parse,     &dns_mx_push,     &dns_mx_cmp,     &dns_mx_print,     &dns_mx_cname,    },
-	{ DNS_T_NS,     "NS",     0,                 &dns_ns_parse,     &dns_ns_push,     &dns_ns_cmp,     &dns_ns_print,     &dns_ns_cname,    },
-	{ DNS_T_CNAME,  "CNAME",  0,                 &dns_cname_parse,  &dns_cname_push,  &dns_cname_cmp,  &dns_cname_print,  &dns_cname_cname, },
-	{ DNS_T_SOA,    "SOA",    0,                 &dns_soa_parse,    &dns_soa_push,    &dns_soa_cmp,    &dns_soa_print,    0,                },
-	{ DNS_T_SRV,    "SRV",    0,                 &dns_srv_parse,    &dns_srv_push,    &dns_srv_cmp,    &dns_srv_print,    &dns_srv_cname,   },
-	{ DNS_T_OPT,    "OPT",    &dns_opt_initany,  &dns_opt_parse,    &dns_opt_push,    &dns_opt_cmp,    &dns_opt_print,    0,                },
-	{ DNS_T_PTR,    "PTR",    0,                 &dns_ptr_parse,    &dns_ptr_push,    &dns_ptr_cmp,    &dns_ptr_print,    &dns_ptr_cname,   },
-	{ DNS_T_TXT,    "TXT",    &dns_txt_initany,  &dns_txt_parse,    &dns_txt_push,    &dns_txt_cmp,    &dns_txt_print,    0,                },
-	{ DNS_T_SPF,    "SPF",    &dns_txt_initany,  &dns_txt_parse,    &dns_txt_push,    &dns_txt_cmp,    &dns_txt_print,    0,                },
-	{ DNS_T_SSHFP,  "SSHFP",  0,                 &dns_sshfp_parse,  &dns_sshfp_push,  &dns_sshfp_cmp,  &dns_sshfp_print,  0,                },
-	{ DNS_T_AXFR,   "AXFR",   0,                 0,                 0,                0,               0,                 0,                },
+#define DNS_RR_ENTRY(T, N, I, Pa, Pu, C, Pr, Cn) \
+	{ T, N, I, (dns_rr_parse_f)(Pa), (dns_rr_push_f)(Pu), (dns_rr_cmp_f)(C), (dns_rr_print_f)(Pr), (dns_rr_cname_f)(Cn) }
+	DNS_RR_ENTRY(DNS_T_A,      "A",      0,                 &dns_a_parse,      &dns_a_push,      &dns_a_cmp,      &dns_a_print,      0),
+	DNS_RR_ENTRY(DNS_T_AAAA,   "AAAA",   0,                 &dns_aaaa_parse,   &dns_aaaa_push,   &dns_aaaa_cmp,   &dns_aaaa_print,   0),
+	DNS_RR_ENTRY(DNS_T_MX,     "MX",     0,                 &dns_mx_parse,     &dns_mx_push,     &dns_mx_cmp,     &dns_mx_print,     &dns_mx_cname),
+	DNS_RR_ENTRY(DNS_T_NS,     "NS",     0,                 &dns_ns_parse,     &dns_ns_push,     &dns_ns_cmp,     &dns_ns_print,     &dns_ns_cname),
+	DNS_RR_ENTRY(DNS_T_CNAME,  "CNAME",  0,                 &dns_cname_parse,  &dns_cname_push,  &dns_cname_cmp,  &dns_cname_print,  &dns_cname_cname),
+	DNS_RR_ENTRY(DNS_T_SOA,    "SOA",    0,                 &dns_soa_parse,    &dns_soa_push,    &dns_soa_cmp,    &dns_soa_print,    0),
+	DNS_RR_ENTRY(DNS_T_SRV,    "SRV",    0,                 &dns_srv_parse,    &dns_srv_push,    &dns_srv_cmp,    &dns_srv_print,    &dns_srv_cname),
+	DNS_RR_ENTRY(DNS_T_OPT,    "OPT",    &dns_opt_initany,  &dns_opt_parse,    &dns_opt_push,    &dns_opt_cmp,    &dns_opt_print,    0),
+	DNS_RR_ENTRY(DNS_T_PTR,    "PTR",    0,                 &dns_ptr_parse,    &dns_ptr_push,    &dns_ptr_cmp,    &dns_ptr_print,    &dns_ptr_cname),
+	DNS_RR_ENTRY(DNS_T_TXT,    "TXT",    &dns_txt_initany,  &dns_txt_parse,    &dns_txt_push,    &dns_txt_cmp,    &dns_txt_print,    0),
+	DNS_RR_ENTRY(DNS_T_SPF,    "SPF",    &dns_txt_initany,  &dns_txt_parse,    &dns_txt_push,    &dns_txt_cmp,    &dns_txt_print,    0),
+	DNS_RR_ENTRY(DNS_T_SSHFP,  "SSHFP",  0,                 &dns_sshfp_parse,  &dns_sshfp_push,  &dns_sshfp_cmp,  &dns_sshfp_print,  0),
+	DNS_RR_ENTRY(DNS_T_DS,     "DS",     0,                 &dns_ds_parse,     &dns_ds_push,     &dns_ds_cmp,     &dns_ds_print,     0),
+	DNS_RR_ENTRY(DNS_T_DNSKEY, "DNSKEY", 0,                 &dns_dnskey_parse, &dns_dnskey_push, &dns_dnskey_cmp, &dns_dnskey_print, 0),
+	DNS_RR_ENTRY(DNS_T_RRSIG,  "RRSIG",  0,                 &dns_rrsig_parse,  &dns_rrsig_push,  &dns_rrsig_cmp,  &dns_rrsig_print,  0),
+	DNS_RR_ENTRY(DNS_T_NSEC,   "NSEC",   0,                 &dns_nsec_parse,   &dns_nsec_push,   &dns_nsec_cmp,   &dns_nsec_print,   0),
+	DNS_RR_ENTRY(DNS_T_NSEC3,  "NSEC3",  0,                 &dns_nsec3_parse,  &dns_nsec3_push,  &dns_nsec3_cmp,  &dns_nsec3_print,  0),
+	DNS_RR_ENTRY(DNS_T_TLSA,   "TLSA",   0,                 &dns_tlsa_parse,   &dns_tlsa_push,   &dns_tlsa_cmp,   &dns_tlsa_print,   0),
+	DNS_RR_ENTRY(DNS_T_SVCB,   "SVCB",   0,                 &dns_svcb_parse,   &dns_svcb_push,   &dns_svcb_cmp,   &dns_svcb_print,   0),
+	DNS_RR_ENTRY(DNS_T_HTTPS,  "HTTPS",  0,                 &dns_svcb_parse,   &dns_svcb_push,   &dns_svcb_cmp,   &dns_svcb_print,   0),
+	DNS_RR_ENTRY(DNS_T_CAA,    "CAA",    0,                 &dns_caa_parse,    &dns_caa_push,    &dns_caa_cmp,    &dns_caa_print,    0),
+	DNS_RR_ENTRY(DNS_T_URI,    "URI",    0,                 &dns_uri_parse,    &dns_uri_push,    &dns_uri_cmp,    &dns_uri_print,    0),
+	DNS_RR_ENTRY(DNS_T_AXFR,   "AXFR",   0,                 0,                 0,                0,               0,                 0),
+#undef DNS_RR_ENTRY
 }; /* dns_rrtypes[] */
 
 static const struct dns_rrtype *dns_rrtype(enum dns_type type) {
@@ -4010,6 +5276,9 @@ int dns_any_parse(union dns_any *any, struct dns_rr *rr, struct dns_packet *P) {
 	if ((t = dns_rrtype(rr->type)))
 		return t->parse(dns_any_reinit(any, t), rr, P);
 
+	/* Validate RDATA bounds */
+	if (rr->rd.len > P->end - rr->rd.p)
+		return DNS_EILLEGAL;
 	if (rr->rd.len > any->rdata.size)
 		return DNS_EILLEGAL;
 
@@ -4169,6 +5438,12 @@ struct dns_hosts *dns_hosts_mortal(struct dns_hosts *hosts) {
 } /* dns_hosts_mortal() */
 
 
+#if _WIN32
+#define DNS_HOSTS_PATH "C:\\Windows\\System32\\drivers\\etc\\hosts"
+#else
+#define DNS_HOSTS_PATH "/etc/hosts"
+#endif
+
 struct dns_hosts *dns_hosts_local(int *error_) {
 	struct dns_hosts *hosts;
 	int error;
@@ -4176,7 +5451,7 @@ struct dns_hosts *dns_hosts_local(int *error_) {
 	if (!(hosts = dns_hosts_open(&error)))
 		goto error;
 
-	if ((error = dns_hosts_loadpath(hosts, "/etc/hosts")))
+	if ((error = dns_hosts_loadpath(hosts, DNS_HOSTS_PATH)))
 		goto error;
 
 	return hosts;
@@ -4482,6 +5757,88 @@ struct dns_resolv_conf *dns_resconf_mortal(struct dns_resolv_conf *resconf) {
 } /* dns_resconf_mortal() */
 
 
+#if _WIN32
+/*
+ * Load DNS configuration from Windows using GetAdaptersAddresses.
+ * This retrieves DNS servers (IPv4 and IPv6) from all adapters,
+ * prioritized by adapter metric (lowest metric = highest priority).
+ */
+static int dns_resconf_loadwin(struct dns_resolv_conf *resconf) {
+	IP_ADAPTER_ADDRESSES *adapters = NULL, *adapter;
+	IP_ADAPTER_DNS_SERVER_ADDRESS *dns;
+	ULONG size = 15000; /* recommended initial size */
+	ULONG ret;
+	size_t count = 0;
+
+	/* Allocate and call GetAdaptersAddresses */
+	for (int tries = 0; tries < 3; tries++) {
+		adapters = malloc(size);
+		if (!adapters)
+			return ENOMEM;
+
+		ret = GetAdaptersAddresses(AF_UNSPEC,
+			GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_FRIENDLY_NAME,
+			NULL, adapters, &size);
+
+		if (ret == ERROR_SUCCESS)
+			break;
+
+		free(adapters);
+		adapters = NULL;
+
+		if (ret != ERROR_BUFFER_OVERFLOW)
+			return (ret == ERROR_NO_DATA) ? ENOENT : EINVAL;
+	}
+
+	if (!adapters)
+		return ENOMEM;
+
+	/*
+	 * Iterate adapters. Windows typically returns them in metric order,
+	 * so we just take DNS servers from each operational adapter until full.
+	 */
+	for (adapter = adapters; adapter && count < lengthof(resconf->nameserver); adapter = adapter->Next) {
+		/* Skip non-operational adapters */
+		if (adapter->OperStatus != IfOperStatusUp)
+			continue;
+
+		/* Load DNS suffix from first adapter that has one */
+		if (resconf->search[0][0] == '\0' && adapter->DnsSuffix && adapter->DnsSuffix[0] != L'\0') {
+			char suffix[DNS_D_MAXNAME];
+			int len = WideCharToMultiByte(CP_UTF8, 0, adapter->DnsSuffix, -1,
+			                               suffix, sizeof suffix, NULL, NULL);
+			if (len > 0) {
+				dns_d_anchor(resconf->search[0], sizeof resconf->search[0],
+				             suffix, strlen(suffix));
+			}
+		}
+
+		/* Add DNS servers from this adapter */
+		for (dns = adapter->FirstDnsServerAddress; dns && count < lengthof(resconf->nameserver); dns = dns->Next) {
+			struct sockaddr *sa = dns->Address.lpSockaddr;
+
+			if (sa->sa_family == AF_INET) {
+				memcpy(&resconf->nameserver[count], sa, sizeof(struct sockaddr_in));
+				((struct sockaddr_in *)&resconf->nameserver[count])->sin_port = htons(53);
+				count++;
+			} else if (sa->sa_family == AF_INET6) {
+				struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
+				/* Skip link-local addresses without proper scope */
+				if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) && sin6->sin6_scope_id == 0)
+					continue;
+				memcpy(&resconf->nameserver[count], sa, sizeof(struct sockaddr_in6));
+				((struct sockaddr_in6 *)&resconf->nameserver[count])->sin6_port = htons(53);
+				count++;
+			}
+		}
+	}
+
+	free(adapters);
+	return 0;
+} /* dns_resconf_loadwin() */
+#endif
+
+
 struct dns_resolv_conf *dns_resconf_local(int *error_) {
 	struct dns_resolv_conf *resconf;
 	int error;
@@ -4489,6 +5846,16 @@ struct dns_resolv_conf *dns_resconf_local(int *error_) {
 	if (!(resconf = dns_resconf_open(&error)))
 		goto error;
 
+#if _WIN32
+	if ((error = dns_resconf_loadwin(resconf))) {
+		/*
+		 * If GetAdaptersAddresses fails, fall back to the default
+		 * nameserver (127.0.0.1) set by dns_resconf_open.
+		 */
+		if (error != ENOENT)
+			goto error;
+	}
+#else
 	if ((error = dns_resconf_loadpath(resconf, "/etc/resolv.conf"))) {
 		/*
 		 * NOTE: Both the glibc and BIND9 resolvers ignore a missing
@@ -4505,6 +5872,7 @@ struct dns_resolv_conf *dns_resconf_local(int *error_) {
 		if (error != ENOENT)
 			goto error;
 	}
+#endif
 
 	return resconf;
 error:
@@ -4550,6 +5918,8 @@ enum dns_resconf_keyword {
 	DNS_RESCONF_ROTATE,
 	DNS_RESCONF_RECURSE,
 	DNS_RESCONF_SMART,
+	DNS_RESCONF_AD,
+	DNS_RESCONF_CD,
 	DNS_RESCONF_TCP,
 	DNS_RESCONF_TCPx,
 	DNS_RESCONF_INTERFACE,
@@ -4577,6 +5947,8 @@ static enum dns_resconf_keyword dns_resconf_keyword(const char *word) {
 		[DNS_RESCONF_ROTATE]		= "rotate",
 		[DNS_RESCONF_RECURSE]		= "recurse",
 		[DNS_RESCONF_SMART]		= "smart",
+		[DNS_RESCONF_AD]		= "ad",
+		[DNS_RESCONF_CD]		= "cd",
 		[DNS_RESCONF_TCP]		= "tcp",
 		[DNS_RESCONF_INTERFACE]		= "interface",
 		[DNS_RESCONF_ZERO]		= "0",
@@ -4801,6 +6173,14 @@ int dns_resconf_loadfile(struct dns_resolv_conf *resconf, FILE *fp) {
 				case DNS_RESCONF_SMART:
 					resconf->options.smart		= 1;
 
+					break;
+				case DNS_RESCONF_AD:
+					resconf->options.ad		= 1;
+
+					break;
+				case DNS_RESCONF_CD:
+					resconf->options.cd		= 1;
+
 					break;
 				case DNS_RESCONF_TCP:
 					resconf->options.tcp		= DNS_RESCONF_TCP_ONLY;
@@ -5501,6 +6881,10 @@ int dns_resconf_dump(struct dns_resolv_conf *resconf, FILE *fp) {
 		fprintf(fp, " recurse");
 	if (resconf->options.smart)
 		fprintf(fp, " smart");
+	if (resconf->options.ad)
+		fprintf(fp, " ad");
+	if (resconf->options.cd)
+		fprintf(fp, " cd");
 
 	switch (resconf->options.tcp) {
 	case DNS_RESCONF_TCP_ENABLE:
@@ -6115,11 +7499,19 @@ static void dns_socketclose(int *fd, const struct dns_options *opts) {
 #endif
 
 #ifndef HAVE_SOCK_CLOEXEC
-#define HAVE_SOCK_CLOEXEC (defined SOCK_CLOEXEC)
+#ifdef SOCK_CLOEXEC
+#define HAVE_SOCK_CLOEXEC 1
+#else
+#define HAVE_SOCK_CLOEXEC 0
+#endif
 #endif
 
 #ifndef HAVE_SOCK_NONBLOCK
-#define HAVE_SOCK_NONBLOCK (defined SOCK_NONBLOCK)
+#ifdef SOCK_NONBLOCK
+#define HAVE_SOCK_NONBLOCK 1
+#else
+#define HAVE_SOCK_NONBLOCK 0
+#endif
 #endif
 
 #define DNS_SO_MAXTRY	7
@@ -6518,6 +7910,9 @@ static _Bool dns_so_tcp_keep(struct dns_socket *so) {
 #if defined __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Warray-bounds"
+#elif DNS_GNUC_PREREQ(4,6,0)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
 #endif
 
 static int dns_so_tcp_send(struct dns_socket *so) {
@@ -6582,8 +7977,10 @@ static int dns_so_tcp_recv(struct dns_socket *so) {
 	return 0;
 } /* dns_so_tcp_recv() */
 
-#if __clang__
+#if defined __clang__
 #pragma clang diagnostic pop
+#elif DNS_GNUC_PREREQ(4,6,0)
+#pragma GCC diagnostic pop
 #endif
 
 
@@ -6595,11 +7992,13 @@ int dns_so_check(struct dns_socket *so) {
 	switch (so->state) {
 	case DNS_SO_UDP_INIT:
 		so->state++;
+		DNS_FALLTHROUGH;
 	case DNS_SO_UDP_CONN:
 		if (0 != connect(so->udp, (struct sockaddr *)&so->remote, dns_sa_len(&so->remote)))
 			goto soerr;
 
 		so->state++;
+		DNS_FALLTHROUGH;
 	case DNS_SO_UDP_SEND:
 		if (0 > (n = send(so->udp, (void *)so->query->data, so->query->end, 0)))
 			goto soerr;
@@ -6608,6 +8007,7 @@ int dns_so_check(struct dns_socket *so) {
 		so->stat.udp.sent.count++;
 
 		so->state++;
+		DNS_FALLTHROUGH;
 	case DNS_SO_UDP_RECV:
 		if (0 > (n = recv(so->udp, (void *)so->answer->data, so->answer->size, 0)))
 			goto soerr;
@@ -6622,11 +8022,13 @@ int dns_so_check(struct dns_socket *so) {
 			goto trash;
 
 		so->state++;
+		DNS_FALLTHROUGH;
 	case DNS_SO_UDP_DONE:
 		if (!dns_header(so->answer)->tc || so->type == SOCK_DGRAM)
 			return 0;
 
 		so->state++;
+		DNS_FALLTHROUGH;
 	case DNS_SO_TCP_INIT:
 		if (dns_so_tcp_keep(so)) {
 			so->state = DNS_SO_TCP_SEND;
@@ -6641,6 +8043,7 @@ int dns_so_check(struct dns_socket *so) {
 			goto error;
 
 		so->state++;
+		DNS_FALLTHROUGH;
 	case DNS_SO_TCP_CONN:
 		if (0 != connect(so->tcp, (struct sockaddr *)&so->remote, dns_sa_len(&so->remote))) {
 			if (dns_soerr() != DNS_EISCONN)
@@ -6648,16 +8051,19 @@ int dns_so_check(struct dns_socket *so) {
 		}
 
 		so->state++;
+		DNS_FALLTHROUGH;
 	case DNS_SO_TCP_SEND:
 		if ((error = dns_so_tcp_send(so)))
 			goto error;
 
 		so->state++;
+		DNS_FALLTHROUGH;
 	case DNS_SO_TCP_RECV:
 		if ((error = dns_so_tcp_recv(so)))
 			goto error;
 
 		so->state++;
+		DNS_FALLTHROUGH;
 	case DNS_SO_TCP_DONE:
 		/* close unless DNS_RESCONF_TCP_ONLY (see dns_res_tcp2type) */
 		if (so->type != SOCK_STREAM) {
@@ -7029,6 +8435,10 @@ static void dns_res_frame_init(struct dns_resolver *R, struct dns_res_frame *fra
 			frame->qflags |= DNS_Q_RD;
 		if (R->resconf->options.edns0)
 			frame->qflags |= DNS_Q_EDNS0;
+		if (R->resconf->options.ad)
+			frame->qflags |= DNS_Q_AD;
+		if (R->resconf->options.cd)
+			frame->qflags |= DNS_Q_CD;
 	}
 } /* dns_res_frame_init() */
 
@@ -7269,6 +8679,7 @@ static int dns_res_exec(struct dns_resolver *R) {
 	switch (F->state) {
 	case DNS_R_INIT:
 		F->state++;
+		DNS_FALLTHROUGH;
 	case DNS_R_GLUE:
 		if (R->sp == 0)
 			dgoto(R->sp, DNS_R_SWITCH);
@@ -7383,16 +8794,19 @@ static int dns_res_exec(struct dns_resolver *R) {
 			goto error;
 
 		F->state++;
+		DNS_FALLTHROUGH;
 	case DNS_R_SUBMIT:
 		if ((error = R->cache->submit(F->query, R->cache)))
 			goto error;
 
 		F->state++;
+		DNS_FALLTHROUGH;
 	case DNS_R_CHECK:
 		if ((error = R->cache->check(R->cache)))
 			goto error;
 
 		F->state++;
+		DNS_FALLTHROUGH;
 	case DNS_R_FETCH:
 		error = 0;
 
@@ -7418,6 +8832,7 @@ static int dns_res_exec(struct dns_resolver *R) {
 		R->search = 0;
 
 		F->state++;
+		DNS_FALLTHROUGH;
 	case DNS_R_SEARCH:
 		/*
 		 * XXX: We probably should only apply the domain search
@@ -7430,11 +8845,13 @@ static int dns_res_exec(struct dns_resolver *R) {
 			goto error;
 
 		F->state++;
+		DNS_FALLTHROUGH;
 	case DNS_R_HINTS:
 		if (!dns_p_setptr(&F->hints, dns_hints_query(R->hints, F->query, &error)))
 			goto error;
 
 		F->state++;
+		DNS_FALLTHROUGH;
 	case DNS_R_ITERATE:
 		dns_rr_i_init(&F->hints_i, F->hints);
 
@@ -7444,6 +8861,7 @@ static int dns_res_exec(struct dns_resolver *R) {
 		F->hints_i.args[0]	= F->hints->end;
 
 		F->state++;
+		DNS_FALLTHROUGH;
 	case DNS_R_FOREACH_NS:
 		dns_rr_i_save(&F->hints_i);
 
@@ -7532,6 +8950,7 @@ static int dns_res_exec(struct dns_resolver *R) {
 			goto error;
 
 		F->state++;
+		DNS_FALLTHROUGH;
 	}
 	case DNS_R_QUERY_A:
 		if (dns_so_elapsed(&R->so) >= dns_resconf_timeout(R->resconf))
@@ -7636,6 +9055,7 @@ static int dns_res_exec(struct dns_resolver *R) {
 		dns_rr_i_init(&R->smart, F->answer);
 
 		F->state++;
+		DNS_FALLTHROUGH;
 	case DNS_R_SMART0_A:
 		if (&F[1] >= endof(R->stack))
 			dgoto(R->sp, DNS_R_DONE);
@@ -8287,11 +9707,13 @@ int dns_ai_nextent(struct addrinfo **ent, struct dns_addrinfo *ai) {
 	switch (ai->state) {
 	case DNS_AI_S_INIT:
 		ai->state++;
+		DNS_FALLTHROUGH;
 	case DNS_AI_S_NEXTAF:
 		if (!dns_ai_nextaf(ai))
 			dns_ai_goto(DNS_AI_S_DONE);
 
 		ai->state++;
+		DNS_FALLTHROUGH;
 	case DNS_AI_S_NUMERIC:
 		if (1 == dns_inet_pton(AF_INET, ai->qname, &any.a)) {
 			if (ai->af.atype == AF_INET) {
@@ -8315,6 +9737,7 @@ int dns_ai_nextent(struct addrinfo **ent, struct dns_addrinfo *ai) {
 			dns_ai_goto(DNS_AI_S_NEXTAF);
 
 		ai->state++;
+		DNS_FALLTHROUGH;
 	case DNS_AI_S_SUBMIT:
 		assert(ai->res);
 
@@ -8322,11 +9745,13 @@ int dns_ai_nextent(struct addrinfo **ent, struct dns_addrinfo *ai) {
 			return error;
 
 		ai->state++;
+		DNS_FALLTHROUGH;
 	case DNS_AI_S_CHECK:
 		if ((error = dns_res_check(ai->res)))
 			return error;
 
 		ai->state++;
+		DNS_FALLTHROUGH;
 	case DNS_AI_S_FETCH:
 		if (!(ans = dns_res_fetch_and_study(ai->res, &error)))
 			return error;
@@ -8350,6 +9775,7 @@ int dns_ai_nextent(struct addrinfo **ent, struct dns_addrinfo *ai) {
 		ai->i.sort    = &dns_rr_i_order;
 
 		ai->state++;
+		DNS_FALLTHROUGH;
 	case DNS_AI_S_FOREACH_I:
 		if (!dns_rr_grep(&rr, 1, &ai->i, ai->answer, &error))
 			dns_ai_goto(DNS_AI_S_NEXTAF);
@@ -8384,10 +9810,12 @@ int dns_ai_nextent(struct addrinfo **ent, struct dns_addrinfo *ai) {
 		} /* switch() */
 
 		ai->state++;
+		DNS_FALLTHROUGH;
 	case DNS_AI_S_INIT_G:
 		ai->g_depth = 0;
 
 		ai->state++;
+		DNS_FALLTHROUGH;
 	case DNS_AI_S_ITERATE_G:
 		dns_strlcpy(ai->g_cname, ai->cname, sizeof ai->g_cname);
 		dns_rr_i_init(&ai->g, ai->glue);
@@ -8396,6 +9824,7 @@ int dns_ai_nextent(struct addrinfo **ent, struct dns_addrinfo *ai) {
 		ai->g.type    = ai->af.qtype;
 
 		ai->state++;
+		DNS_FALLTHROUGH;
 	case DNS_AI_S_FOREACH_G:
 		if (!dns_rr_grep(&rr, 1, &ai->g, ai->glue, &error)) {
 			if (dns_rr_i_count(&ai->g) > 0)
@@ -8420,11 +9849,13 @@ int dns_ai_nextent(struct addrinfo **ent, struct dns_addrinfo *ai) {
 			return error;
 
 		ai->state++;
+		DNS_FALLTHROUGH;
 	case DNS_AI_S_CHECK_G:
 		if ((error = dns_res_check(ai->res)))
 			return error;
 
 		ai->state++;
+		DNS_FALLTHROUGH;
 	case DNS_AI_S_FETCH_G:
 		if (!(ans = dns_res_fetch_and_study(ai->res, &error)))
 			return error;
@@ -8560,6 +9991,326 @@ const struct dns_stat *dns_ai_stat(struct dns_addrinfo *ai) {
 } /* dns_ai_stat() */
 
 
+/*
+ * S Y N C H R O N O U S  I N T E R F A C E S
+ *
+ * Blocking wrappers similar to getaddrinfo(3) and getnameinfo(3).
+ *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#define DNS_GETADDRINFO_DEFAULT_TIMEOUT 30
+
+static int dns_poll_ms(int fd, short events, int timeout_ms) {
+	if (!events)
+		return 0;
+
+#if _WIN32
+	fd_set rset, wset;
+	struct timeval tv;
+
+	FD_ZERO(&rset);
+	FD_ZERO(&wset);
+
+	if (events & DNS_POLLIN)
+		FD_SET(fd, &rset);
+
+	if (events & DNS_POLLOUT)
+		FD_SET(fd, &wset);
+
+	if (timeout_ms >= 0) {
+		tv.tv_sec = timeout_ms / 1000;
+		tv.tv_usec = (timeout_ms % 1000) * 1000;
+		return select(fd + 1, &rset, &wset, 0, &tv);
+	} else {
+		return select(fd + 1, &rset, &wset, 0, NULL);
+	}
+#else
+	struct pollfd pfd;
+
+	pfd.fd = fd;
+	pfd.events = 0;
+	pfd.revents = 0;
+
+	if (events & DNS_POLLIN)
+		pfd.events |= POLLIN;
+
+	if (events & DNS_POLLOUT)
+		pfd.events |= POLLOUT;
+
+	return poll(&pfd, 1, timeout_ms);
+#endif
+} /* dns_poll_ms() */
+
+
+static int dns_ai_waitfor(struct dns_addrinfo *ai, int timeout_sec) {
+	time_t deadline, now;
+	int pollfd, events, remaining_ms;
+
+	if (timeout_sec <= 0)
+		timeout_sec = DNS_GETADDRINFO_DEFAULT_TIMEOUT;
+
+	deadline = time(NULL) + timeout_sec;
+
+	while ((now = time(NULL)) < deadline) {
+		pollfd = dns_ai_pollfd(ai);
+		events = dns_ai_events(ai);
+
+		if (pollfd < 0 || !events)
+			return 0; /* ready or done */
+
+		remaining_ms = (int)((deadline - now) * 1000);
+		if (remaining_ms <= 0)
+			break;
+
+		dns_poll_ms(pollfd, events, remaining_ms);
+	}
+
+	return (time(NULL) >= deadline) ? ETIMEDOUT : 0;
+} /* dns_ai_waitfor() */
+
+
+int dns_getaddrinfo(const char *host, const char *serv, const struct addrinfo *hints, struct addrinfo **res, int timeout) {
+	struct dns_resolver *resolver = NULL;
+	struct dns_addrinfo *ai = NULL;
+	struct addrinfo *head = NULL, **tail = &head, *ent;
+	int error;
+
+	*res = NULL;
+
+	if (!host)
+		return EAI_NONAME;
+
+	/* Create stub resolver using system configuration */
+	resolver = dns_res_stub(dns_opts(), &error);
+	if (!resolver) {
+		switch (error) {
+		case ENOMEM:
+			return EAI_MEMORY;
+		default:
+			return EAI_FAIL;
+		}
+	}
+
+	/* Open addrinfo iterator */
+	ai = dns_ai_open(host, serv, DNS_T_A, hints, resolver, &error);
+	if (!ai) {
+		dns_res_close(resolver);
+		switch (error) {
+		case ENOMEM:
+			return EAI_MEMORY;
+		default:
+			return EAI_FAIL;
+		}
+	}
+
+	/* Iterate results with timeout */
+	do {
+		error = dns_ai_nextent(&ent, ai);
+
+		switch (error) {
+		case 0:
+			/* Link entry to result list */
+			*tail = ent;
+			tail = &ent->ai_next;
+			break;
+
+		case ENOENT:
+			/* No more results */
+			break;
+
+		case DNS_EAGAIN:
+			/* Need to wait for I/O */
+			if ((error = dns_ai_waitfor(ai, timeout))) {
+				/* Timeout or error */
+				dns_ai_close(ai);
+				dns_res_close(resolver);
+				dns_freeaddrinfo(head);
+				return (error == ETIMEDOUT) ? EAI_AGAIN : EAI_FAIL;
+			}
+			break;
+
+		default:
+			/* Other error */
+			dns_ai_close(ai);
+			dns_res_close(resolver);
+			dns_freeaddrinfo(head);
+			switch (error) {
+			case ENOMEM:
+				return EAI_MEMORY;
+			case ENOENT:
+				return EAI_NONAME;
+			default:
+				return EAI_FAIL;
+			}
+		}
+	} while (error != ENOENT);
+
+	dns_ai_close(ai);
+	dns_res_close(resolver);
+
+	if (!head)
+		return EAI_NONAME;
+
+	*res = head;
+	return 0;
+} /* dns_getaddrinfo() */
+
+
+void dns_freeaddrinfo(struct addrinfo *res) {
+	struct addrinfo *next;
+
+	while (res) {
+		next = res->ai_next;
+		free(res);
+		res = next;
+	}
+} /* dns_freeaddrinfo() */
+
+
+int dns_getnameinfo(const struct sockaddr *sa, socklen_t salen, char *host, size_t hostlen, char *serv, size_t servlen, int flags, int timeout) {
+	struct dns_resolver *resolver = NULL;
+	struct dns_packet *ans = NULL;
+	struct dns_rr rr;
+	struct dns_rr_i rr_i;
+	union dns_any any;
+	char qname[DNS_D_MAXNAME + 1];
+	time_t deadline, now;
+	int error, pollfd, events, remaining_ms;
+	(void)salen;
+
+	if (timeout <= 0)
+		timeout = DNS_GETADDRINFO_DEFAULT_TIMEOUT;
+
+	deadline = time(NULL) + timeout;
+
+	/* Handle service lookup (port -> service name) */
+	if (serv && servlen > 0) {
+		unsigned short port = 0;
+
+		if (sa->sa_family == AF_INET) {
+			port = ntohs(((const struct sockaddr_in *)sa)->sin_port);
+		} else if (sa->sa_family == AF_INET6) {
+			port = ntohs(((const struct sockaddr_in6 *)sa)->sin6_port);
+		}
+
+		if (flags & NI_NUMERICSERV) {
+			snprintf(serv, servlen, "%u", port);
+		} else {
+			/* For now, just return numeric (service lookup would need /etc/services) */
+			snprintf(serv, servlen, "%u", port);
+		}
+	}
+
+	/* Handle host lookup */
+	if (!host || hostlen == 0)
+		return 0;
+
+	/* If numeric requested, just format the address */
+	if (flags & NI_NUMERICHOST) {
+		const void *addr;
+
+		if (sa->sa_family == AF_INET) {
+			addr = &((const struct sockaddr_in *)sa)->sin_addr;
+		} else if (sa->sa_family == AF_INET6) {
+			addr = &((const struct sockaddr_in6 *)sa)->sin6_addr;
+		} else {
+			return EAI_FAMILY;
+		}
+
+		if (!dns_inet_ntop(sa->sa_family, addr, host, hostlen))
+			return EAI_OVERFLOW;
+
+		return 0;
+	}
+
+	/* Build reverse DNS name (in-addr.arpa or ip6.arpa) */
+	if (!dns_ptr_qname(qname, sizeof qname, sa->sa_family, dns_sa_addr(sa->sa_family, sa, NULL))) {
+		/* Can't build PTR name, return numeric if allowed */
+		if (flags & NI_NAMEREQD)
+			return EAI_NONAME;
+
+		return dns_getnameinfo(sa, salen, host, hostlen, NULL, 0, flags | NI_NUMERICHOST, timeout);
+	}
+
+	/* Create stub resolver */
+	resolver = dns_res_stub(dns_opts(), &error);
+	if (!resolver)
+		return (error == ENOMEM) ? EAI_MEMORY : EAI_FAIL;
+
+	/* Submit PTR query */
+	if ((error = dns_res_submit(resolver, qname, DNS_T_PTR, DNS_C_IN))) {
+		dns_res_close(resolver);
+		return (error == ENOMEM) ? EAI_MEMORY : EAI_FAIL;
+	}
+
+	/* Wait for response with timeout */
+	while ((error = dns_res_check(resolver)) == DNS_EAGAIN) {
+		now = time(NULL);
+		if (now >= deadline) {
+			dns_res_close(resolver);
+			if (flags & NI_NAMEREQD)
+				return EAI_AGAIN;
+			return dns_getnameinfo(sa, salen, host, hostlen, NULL, 0, flags | NI_NUMERICHOST, 0);
+		}
+
+		pollfd = dns_res_pollfd(resolver);
+		events = dns_res_events(resolver);
+		remaining_ms = (int)((deadline - now) * 1000);
+
+		if (pollfd >= 0 && events)
+			dns_poll_ms(pollfd, events, remaining_ms);
+	}
+
+	if (error) {
+		dns_res_close(resolver);
+		if (flags & NI_NAMEREQD)
+			return EAI_NONAME;
+		return dns_getnameinfo(sa, salen, host, hostlen, NULL, 0, flags | NI_NUMERICHOST, 0);
+	}
+
+	/* Get answer packet */
+	ans = dns_res_fetch(resolver, &error);
+	dns_res_close(resolver);
+
+	if (!ans) {
+		if (flags & NI_NAMEREQD)
+			return EAI_NONAME;
+		return dns_getnameinfo(sa, salen, host, hostlen, NULL, 0, flags | NI_NUMERICHOST, 0);
+	}
+
+	/* Find PTR record in answer */
+	memset(&rr_i, 0, sizeof rr_i);
+	rr_i.section = DNS_S_AN;
+	rr_i.type = DNS_T_PTR;
+
+	if (!dns_rr_grep(&rr, 1, &rr_i, ans, &error)) {
+		free(ans);
+		if (flags & NI_NAMEREQD)
+			return EAI_NONAME;
+		return dns_getnameinfo(sa, salen, host, hostlen, NULL, 0, flags | NI_NUMERICHOST, 0);
+	}
+
+	/* Parse PTR record */
+	if (dns_any_parse(&any, &rr, ans)) {
+		free(ans);
+		if (flags & NI_NAMEREQD)
+			return EAI_NONAME;
+		return dns_getnameinfo(sa, salen, host, hostlen, NULL, 0, flags | NI_NUMERICHOST, 0);
+	}
+
+	/* Copy hostname (remove trailing dot if present) */
+	dns_strlcpy(host, any.ptr.host, hostlen);
+	{
+		size_t len = strlen(host);
+		if (len > 0 && host[len - 1] == '.')
+			host[len - 1] = '\0';
+	}
+
+	free(ans);
+	return 0;
+} /* dns_getnameinfo() */
+
+
 /*
  * M I S C E L L A N E O U S  R O U T I N E S
  *
@@ -8700,38 +10451,19 @@ enum dns_type dns_itype(const char *name) {
 } /* dns_itype() */
 
 
-static char dns_opcodes[16][16] = {
+static const char dns_opcodes[16][16] = {
 	[DNS_OP_QUERY]  = "QUERY",
 	[DNS_OP_IQUERY] = "IQUERY",
 	[DNS_OP_STATUS] = "STATUS",
+	[3]             = "3",
 	[DNS_OP_NOTIFY] = "NOTIFY",
 	[DNS_OP_UPDATE] = "UPDATE",
+	[6] = "6", [7] = "7", [8] = "8", [9] = "9",
+	[10] = "10", [11] = "11", [12] = "12", [13] = "13", [14] = "14", [15] = "15",
 };
 
-static const char *dns__strcode(int code, volatile char *dst, size_t lim) {
-	char _tmp[48] = "";
-	struct dns_buf tmp;
-	size_t p;
-
-	assert(lim > 0);
-	dns_b_fmtju(dns_b_into(&tmp, _tmp, DNS_PP_MIN(sizeof _tmp, lim - 1)), code, 0);
-
-	/* copy downwards so first byte is copied last (see below) */
-	p = (size_t)(tmp.p - tmp.base);
-	dst[p] = '\0';
-	while (p--)
-		dst[p] = _tmp[p];
-
-	return (const char *)dst;
-}
-
 const char *dns_stropcode(enum dns_opcode opcode) {
-	opcode = (unsigned)opcode % lengthof(dns_opcodes);
-
-	if ('\0' == dns_opcodes[opcode][0])
-		return dns__strcode(opcode, dns_opcodes[opcode], sizeof dns_opcodes[opcode]);
-
-	return dns_opcodes[opcode];
+	return dns_opcodes[(unsigned)opcode % lengthof(dns_opcodes)];
 } /* dns_stropcode() */
 
 
@@ -8753,7 +10485,7 @@ enum dns_opcode dns_iopcode(const char *name) {
 } /* dns_iopcode() */
 
 
-static char dns_rcodes[32][16] = {
+static const char dns_rcodes[32][16] = {
 	[DNS_RC_NOERROR]  = "NOERROR",
 	[DNS_RC_FORMERR]  = "FORMERR",
 	[DNS_RC_SERVFAIL] = "SERVFAIL",
@@ -8765,17 +10497,17 @@ static char dns_rcodes[32][16] = {
 	[DNS_RC_NXRRSET]  = "NXRRSET",
 	[DNS_RC_NOTAUTH]  = "NOTAUTH",
 	[DNS_RC_NOTZONE]  = "NOTZONE",
+	[11] = "11", [12] = "12", [13] = "13", [14] = "14", [15] = "15",
 	/* EDNS(0) extended RCODEs ... */
 	[DNS_RC_BADVERS]  = "BADVERS",
+	[17] = "17", [18] = "18", [19] = "19",
+	[20] = "20", [21] = "21", [22] = "22", [23] = "23",
+	[24] = "24", [25] = "25", [26] = "26", [27] = "27",
+	[28] = "28", [29] = "29", [30] = "30", [31] = "31",
 };
 
 const char *dns_strrcode(enum dns_rcode rcode) {
-	rcode = (unsigned)rcode % lengthof(dns_rcodes);
-
-	if ('\0' == dns_rcodes[rcode][0])
-		return dns__strcode(rcode, dns_rcodes[rcode], sizeof dns_rcodes[rcode]);
-
-	return dns_rcodes[rcode];
+	return dns_rcodes[(unsigned)rcode % lengthof(dns_rcodes)];
 } /* dns_strrcode() */
 
 
@@ -8828,9 +10560,14 @@ struct {
 	const char *qname;
 	enum dns_type qtype;
 
-	int (*sort)();
+	int (*sort)(struct dns_rr *, struct dns_rr *, struct dns_rr_i *, struct dns_packet *);
 
 	int verbose;
+
+	struct {
+		_Bool ad;
+		_Bool cd;
+	} qflags;
 } MAIN = {
 	.sort	= &dns_rr_i_packet,
 };
@@ -8947,8 +10684,15 @@ static struct dns_resolv_conf *resconf(void) {
 	if (!(resconf = dns_resconf_open(&error)))
 		panic("dns_resconf_open: %s", dns_strerror(error));
 
+#if _WIN32
+	if (!MAIN.resconf.count) {
+		if ((error = dns_resconf_loadwin(resconf)))
+			panic("dns_resconf_loadwin: %s", dns_strerror(error));
+	}
+#else
 	if (!MAIN.resconf.count)
 		MAIN.resconf.path[MAIN.resconf.count++]	= "/etc/resolv.conf";
+#endif
 
 	for (i = 0; i < MAIN.resconf.count; i++) {
 		path	= MAIN.resconf.path[i];
@@ -8962,6 +10706,7 @@ static struct dns_resolv_conf *resconf(void) {
 			panic("%s: %s", path, dns_strerror(error));
 	}
 
+#if !_WIN32
 	for (i = 0; i < MAIN.nssconf.count; i++) {
 		path	= MAIN.nssconf.path[i];
 
@@ -8982,6 +10727,13 @@ static struct dns_resolv_conf *resconf(void) {
 		else if (error != ENOENT)
 			panic("%s: %s", path, dns_strerror(error));
 	}
+#endif
+
+	/* apply command-line query flags */
+	if (MAIN.qflags.ad)
+		resconf->options.ad = 1;
+	if (MAIN.qflags.cd)
+		resconf->options.cd = 1;
 
 	return resconf;
 } /* resconf() */
@@ -8997,11 +10749,11 @@ static struct dns_hosts *hosts(void) {
 		return hosts;
 
 	if (!MAIN.hosts.count) {
-		MAIN.hosts.path[MAIN.hosts.count++]	= "/etc/hosts";
+		MAIN.hosts.path[MAIN.hosts.count++]	= DNS_HOSTS_PATH;
 
 		/* Explicitly test dns_hosts_local() */
 		if (!(hosts = dns_hosts_local(&error)))
-			panic("%s: %s", "/etc/hosts", dns_strerror(error));
+			panic("%s: %s", DNS_HOSTS_PATH, dns_strerror(error));
 
 		return hosts;
 	}
@@ -9439,6 +11191,7 @@ static int send_query(int argc, char *argv[]) {
 
 	print_packet(A, stdout);
 
+	free(A);
 	dns_so_close(so);
 
 	return 0;
@@ -9503,7 +11256,7 @@ static int show_hints(int argc, char *argv[]) {
 
 static int resolve_query(int argc DNS_NOTUSED, char *argv[]) {
 	_Bool recurse = !!strstr(argv[0], "recurse");
-	struct dns_hints *(*hints)() = (recurse)? &dns_hints_root : &dns_hints_local;
+	struct dns_hints *(*hints)(struct dns_resolv_conf *, int *) = (recurse)? &dns_hints_root : &dns_hints_local;
 	struct dns_resolver *R;
 	struct dns_packet *ans;
 	const struct dns_stat *st;
@@ -9551,7 +11304,7 @@ static int resolve_query(int argc DNS_NOTUSED, char *argv[]) {
 
 static int resolve_addrinfo(int argc DNS_NOTUSED, char *argv[]) {
 	_Bool recurse = !!strstr(argv[0], "recurse");
-	struct dns_hints *(*hints)() = (recurse)? &dns_hints_root : &dns_hints_local;
+	struct dns_hints *(*hints)(struct dns_resolv_conf *, int *) = (recurse)? &dns_hints_root : &dns_hints_local;
 	struct dns_resolver *res = NULL;
 	struct dns_addrinfo *ai = NULL;
 	struct addrinfo ai_hints = { .ai_family = PF_UNSPEC, .ai_socktype = SOCK_STREAM, .ai_flags = AI_CANONNAME };
@@ -9740,7 +11493,7 @@ static int sizes(int argc DNS_NOTUSED, char *argv[] DNS_NOTUSED) {
 } /* sizes() */
 
 
-static const struct { const char *cmd; int (*run)(); const char *help; } cmds[] = {
+static const struct { const char *cmd; int (*run)(int, char *[]); const char *help; } cmds[] = {
 	{ "parse-packet",	&parse_packet,		"parse binary packet from stdin" },
 	{ "parse-domain",	&parse_domain,		"anchor and iteratively cleave domain" },
 	{ "trim-domain",	&trim_domain,		"trim and anchor domain name" },
@@ -9783,6 +11536,8 @@ static void print_usage(const char *progname, FILE *fp) {
 		"  -q QNAME  Query name\n"
 		"  -t QTYPE  Query type\n"
 		"  -s HOW    Sort records\n"
+		"  -A        Set AD bit (request authenticated data)\n"
+		"  -D        Set CD bit (disable DNSSEC validation)\n"
 		"  -v        Be more verbose (-vv show packets; -vvv hexdump packets)\n"
 		"  -V        Print version info\n"
 		"  -h        Print this usage message\n"
@@ -9827,7 +11582,14 @@ int main(int argc, char **argv) {
 	unsigned i;
 	int ch;
 
-	while (-1 != (ch = getopt(argc, argv, "q:t:c:n:l:z:s:vVh"))) {
+#if _WIN32
+	{
+		WSADATA wsaData;
+		WSAStartup(MAKEWORD(2, 2), &wsaData);
+	}
+#endif
+
+	while (-1 != (ch = getopt(argc, argv, "q:t:c:n:l:z:s:ADvVh"))) {
 		switch (ch) {
 		case 'c':
 			assert(MAIN.resconf.count < lengthof(MAIN.resconf.path));
@@ -9885,6 +11647,14 @@ int main(int argc, char **argv) {
 			else
 				panic("%s: invalid sort method", optarg);
 
+			break;
+		case 'A':
+			MAIN.qflags.ad	= 1;
+
+			break;
+		case 'D':
+			MAIN.qflags.cd	= 1;
+
 			break;
 		case 'v':
 			dns_debug = ++MAIN.verbose;
diff --git a/src/dns.h b/src/dns.h
index 78d6402..adf85c7 100644
--- a/src/dns.h
+++ b/src/dns.h
@@ -27,6 +27,7 @@
 #define DNS_H
 
 #include <stddef.h>		/* size_t offsetof() */
+#include <stdint.h>		/* uint8_t uint16_t uint32_t */
 #include <stdio.h>		/* FILE */
 
 #include <string.h>		/* strlen(3) */
@@ -161,9 +162,9 @@ DNS_PUBLIC int *dns_debug_p(void);
 #define DNS_PRAGMA_QUIET _Pragma("GCC diagnostic ignored \"-Woverride-init\"")
 #define DNS_PRAGMA_POP _Pragma("GCC diagnostic pop")
 
-/* GCC parses the _Pragma operator less elegantly than clang. */
-#define dns_quietinit(...) \
-	__extension__ ({ DNS_PRAGMA_PUSH DNS_PRAGMA_QUIET __VA_ARGS__; DNS_PRAGMA_POP })
+/* GCC parses the _Pragma operator less elegantly than clang.
+ * We suppress the warning file-wide and just pass through the expression. */
+#define dns_quietinit(...) __VA_ARGS__
 #else
 #define DNS_PRAGMA_PUSH
 #define DNS_PRAGMA_QUIET
@@ -251,9 +252,19 @@ enum dns_type {
 	DNS_T_AAAA	= 28,
 	DNS_T_SRV	= 33,
 	DNS_T_OPT	= 41,
+	DNS_T_DS	= 43,
 	DNS_T_SSHFP	= 44,
+	DNS_T_RRSIG	= 46,
+	DNS_T_NSEC	= 47,
+	DNS_T_DNSKEY	= 48,
+	DNS_T_NSEC3	= 50,
+	DNS_T_TLSA	= 52,
+	DNS_T_SVCB	= 64,
+	DNS_T_HTTPS	= 65,
 	DNS_T_SPF	= 99,
-	DNS_T_AXFR      = 252,
+	DNS_T_AXFR	= 252,
+	DNS_T_CAA	= 257,
+	DNS_T_URI	= 256,
 
 	DNS_T_ALL	= 255
 }; /* enum dns_type */
@@ -362,7 +373,9 @@ struct dns_header {
 		unsigned rd:1;
 
 		unsigned ra:1;
-		unsigned unused:3;
+		unsigned z:1;
+		unsigned ad:1;  /* RFC 4035: Authenticated Data */
+		unsigned cd:1;  /* RFC 4035: Checking Disabled */
 		unsigned rcode:4;
 #else
 		unsigned rd:1;
@@ -372,7 +385,9 @@ struct dns_header {
 		unsigned qr:1;
 
 		unsigned rcode:4;
-		unsigned unused:3;
+		unsigned cd:1;  /* RFC 4035: Checking Disabled */
+		unsigned ad:1;  /* RFC 4035: Authenticated Data */
+		unsigned z:1;
 		unsigned ra:1;
 #endif
 
@@ -535,7 +550,7 @@ struct dns_rr_i {
 
 	int follow;
 
-	int (*sort)();
+	int (*sort)(struct dns_rr *, struct dns_rr *, struct dns_rr_i *, struct dns_packet *);
 	unsigned args[2];
 
 	struct {
@@ -796,6 +811,261 @@ DNS_PUBLIC int dns_sshfp_cmp(const struct dns_sshfp *, const struct dns_sshfp *)
 DNS_PUBLIC size_t dns_sshfp_print(void *, size_t, struct dns_sshfp *);
 
 
+/*
+ * D S  R E S O U R C E  R E C O R D  (RFC 4034)
+ */
+
+#ifndef DNS_DS_DIGEST_MAXLEN
+#define DNS_DS_DIGEST_MAXLEN 64  /* SHA-384 = 48 bytes, allow room for future */
+#endif
+
+struct dns_ds {
+	uint16_t keytag;
+	uint8_t algorithm;
+	uint8_t digtype;
+	unsigned char digest[DNS_DS_DIGEST_MAXLEN];
+	size_t digestlen;
+}; /* struct dns_ds */
+
+DNS_PUBLIC int dns_ds_parse(struct dns_ds *, struct dns_rr *, struct dns_packet *);
+
+DNS_PUBLIC int dns_ds_push(struct dns_packet *, struct dns_ds *);
+
+DNS_PUBLIC int dns_ds_cmp(const struct dns_ds *, const struct dns_ds *);
+
+DNS_PUBLIC size_t dns_ds_print(void *, size_t, struct dns_ds *);
+
+
+/*
+ * D N S K E Y  R E S O U R C E  R E C O R D  (RFC 4034)
+ */
+
+#ifndef DNS_DNSKEY_PUBKEY_MAXLEN
+#define DNS_DNSKEY_PUBKEY_MAXLEN 2048
+#endif
+
+struct dns_dnskey {
+	uint16_t flags;     /* 256=ZSK, 257=KSK */
+	uint8_t protocol;   /* must be 3 */
+	uint8_t algorithm;
+	unsigned char pubkey[DNS_DNSKEY_PUBKEY_MAXLEN];
+	size_t pubkeylen;
+}; /* struct dns_dnskey */
+
+DNS_PUBLIC int dns_dnskey_parse(struct dns_dnskey *, struct dns_rr *, struct dns_packet *);
+
+DNS_PUBLIC int dns_dnskey_push(struct dns_packet *, struct dns_dnskey *);
+
+DNS_PUBLIC int dns_dnskey_cmp(const struct dns_dnskey *, const struct dns_dnskey *);
+
+DNS_PUBLIC size_t dns_dnskey_print(void *, size_t, struct dns_dnskey *);
+
+
+/*
+ * R R S I G  R E S O U R C E  R E C O R D  (RFC 4034)
+ */
+
+#ifndef DNS_RRSIG_SIG_MAXLEN
+#define DNS_RRSIG_SIG_MAXLEN 2048
+#endif
+
+struct dns_rrsig {
+	uint16_t covered;    /* type covered */
+	uint8_t algorithm;
+	uint8_t labels;
+	uint32_t origttl;
+	uint32_t expiration;
+	uint32_t inception;
+	uint16_t keytag;
+	char signer[DNS_D_MAXNAME + 1];
+	unsigned char signature[DNS_RRSIG_SIG_MAXLEN];
+	size_t siglen;
+}; /* struct dns_rrsig */
+
+DNS_PUBLIC int dns_rrsig_parse(struct dns_rrsig *, struct dns_rr *, struct dns_packet *);
+
+DNS_PUBLIC int dns_rrsig_push(struct dns_packet *, struct dns_rrsig *);
+
+DNS_PUBLIC int dns_rrsig_cmp(const struct dns_rrsig *, const struct dns_rrsig *);
+
+DNS_PUBLIC size_t dns_rrsig_print(void *, size_t, struct dns_rrsig *);
+
+
+/*
+ * N S E C  R E S O U R C E  R E C O R D  (RFC 4034)
+ */
+
+#ifndef DNS_NSEC_TYPEMAP_MAXLEN
+#define DNS_NSEC_TYPEMAP_MAXLEN 8192  /* type bitmap can be large */
+#endif
+
+struct dns_nsec {
+	char next[DNS_D_MAXNAME + 1];
+	unsigned char typemap[DNS_NSEC_TYPEMAP_MAXLEN];
+	size_t typemaplen;
+}; /* struct dns_nsec */
+
+DNS_PUBLIC int dns_nsec_parse(struct dns_nsec *, struct dns_rr *, struct dns_packet *);
+
+DNS_PUBLIC int dns_nsec_push(struct dns_packet *, struct dns_nsec *);
+
+DNS_PUBLIC int dns_nsec_cmp(const struct dns_nsec *, const struct dns_nsec *);
+
+DNS_PUBLIC size_t dns_nsec_print(void *, size_t, struct dns_nsec *);
+
+DNS_PUBLIC _Bool dns_nsec_hastype(const struct dns_nsec *, enum dns_type);
+
+
+/*
+ * N S E C 3  R E S O U R C E  R E C O R D  (RFC 5155)
+ */
+
+#ifndef DNS_NSEC3_SALT_MAXLEN
+#define DNS_NSEC3_SALT_MAXLEN 255
+#endif
+
+#ifndef DNS_NSEC3_HASH_MAXLEN
+#define DNS_NSEC3_HASH_MAXLEN 64  /* SHA-1 = 20 bytes, allow room */
+#endif
+
+struct dns_nsec3 {
+	uint8_t algorithm;
+	uint8_t flags;
+	uint16_t iterations;
+	unsigned char salt[DNS_NSEC3_SALT_MAXLEN];
+	size_t saltlen;
+	unsigned char nexthash[DNS_NSEC3_HASH_MAXLEN];
+	size_t nexthashlen;
+	unsigned char typemap[DNS_NSEC_TYPEMAP_MAXLEN];
+	size_t typemaplen;
+}; /* struct dns_nsec3 */
+
+DNS_PUBLIC int dns_nsec3_parse(struct dns_nsec3 *, struct dns_rr *, struct dns_packet *);
+
+DNS_PUBLIC int dns_nsec3_push(struct dns_packet *, struct dns_nsec3 *);
+
+DNS_PUBLIC int dns_nsec3_cmp(const struct dns_nsec3 *, const struct dns_nsec3 *);
+
+DNS_PUBLIC size_t dns_nsec3_print(void *, size_t, struct dns_nsec3 *);
+
+DNS_PUBLIC _Bool dns_nsec3_hastype(const struct dns_nsec3 *, enum dns_type);
+
+
+/*
+ * T L S A  R E S O U R C E  R E C O R D  (RFC 6698)
+ */
+
+#ifndef DNS_TLSA_DATA_MAXLEN
+#define DNS_TLSA_DATA_MAXLEN 2048
+#endif
+
+struct dns_tlsa {
+	uint8_t usage;      /* 0=CA, 1=Service, 2=TrustAnchor, 3=DomainIssued */
+	uint8_t selector;   /* 0=Full, 1=SubjectPublicKeyInfo */
+	uint8_t matchtype;  /* 0=Full, 1=SHA-256, 2=SHA-512 */
+	unsigned char data[DNS_TLSA_DATA_MAXLEN];
+	size_t datalen;
+}; /* struct dns_tlsa */
+
+DNS_PUBLIC int dns_tlsa_parse(struct dns_tlsa *, struct dns_rr *, struct dns_packet *);
+
+DNS_PUBLIC int dns_tlsa_push(struct dns_packet *, struct dns_tlsa *);
+
+DNS_PUBLIC int dns_tlsa_cmp(const struct dns_tlsa *, const struct dns_tlsa *);
+
+DNS_PUBLIC size_t dns_tlsa_print(void *, size_t, struct dns_tlsa *);
+
+
+/*
+ * C A A  R E S O U R C E  R E C O R D  (RFC 8659)
+ */
+
+#ifndef DNS_CAA_TAG_MAXLEN
+#define DNS_CAA_TAG_MAXLEN 255
+#endif
+
+#ifndef DNS_CAA_VALUE_MAXLEN
+#define DNS_CAA_VALUE_MAXLEN 4096
+#endif
+
+struct dns_caa {
+	uint8_t flags;
+	char tag[DNS_CAA_TAG_MAXLEN + 1];
+	unsigned char value[DNS_CAA_VALUE_MAXLEN];
+	size_t valuelen;
+}; /* struct dns_caa */
+
+DNS_PUBLIC int dns_caa_parse(struct dns_caa *, struct dns_rr *, struct dns_packet *);
+
+DNS_PUBLIC int dns_caa_push(struct dns_packet *, struct dns_caa *);
+
+DNS_PUBLIC int dns_caa_cmp(const struct dns_caa *, const struct dns_caa *);
+
+DNS_PUBLIC size_t dns_caa_print(void *, size_t, struct dns_caa *);
+
+
+/*
+ * U R I  R E S O U R C E  R E C O R D  (RFC 7553)
+ */
+
+#ifndef DNS_URI_TARGET_MAXLEN
+#define DNS_URI_TARGET_MAXLEN 4096
+#endif
+
+struct dns_uri {
+	uint16_t priority;
+	uint16_t weight;
+	char target[DNS_URI_TARGET_MAXLEN + 1];
+}; /* struct dns_uri */
+
+DNS_PUBLIC int dns_uri_parse(struct dns_uri *, struct dns_rr *, struct dns_packet *);
+
+DNS_PUBLIC int dns_uri_push(struct dns_packet *, struct dns_uri *);
+
+DNS_PUBLIC int dns_uri_cmp(const struct dns_uri *, const struct dns_uri *);
+
+DNS_PUBLIC size_t dns_uri_print(void *, size_t, struct dns_uri *);
+
+
+/*
+ * S V C B / H T T P S  R E S O U R C E  R E C O R D  (RFC 9460)
+ */
+
+#ifndef DNS_SVCB_PARAM_MAXLEN
+#define DNS_SVCB_PARAM_MAXLEN 8192
+#endif
+
+/* SvcParamKey values */
+enum dns_svcb_key {
+	DNS_SVCB_KEY_MANDATORY      = 0,
+	DNS_SVCB_KEY_ALPN           = 1,
+	DNS_SVCB_KEY_NO_DEFAULT_ALPN = 2,
+	DNS_SVCB_KEY_PORT           = 3,
+	DNS_SVCB_KEY_IPV4HINT       = 4,
+	DNS_SVCB_KEY_ECH            = 5,
+	DNS_SVCB_KEY_IPV6HINT       = 6,
+	DNS_SVCB_KEY_DOHPATH        = 7,
+	DNS_SVCB_KEY_OHTTP          = 8,
+};
+
+struct dns_svcb {
+	uint16_t priority;
+	char target[DNS_D_MAXNAME + 1];
+	unsigned char params[DNS_SVCB_PARAM_MAXLEN];
+	size_t paramslen;
+}; /* struct dns_svcb */
+
+DNS_PUBLIC int dns_svcb_parse(struct dns_svcb *, struct dns_rr *, struct dns_packet *);
+
+DNS_PUBLIC int dns_svcb_push(struct dns_packet *, struct dns_svcb *);
+
+DNS_PUBLIC int dns_svcb_cmp(const struct dns_svcb *, const struct dns_svcb *);
+
+DNS_PUBLIC size_t dns_svcb_print(void *, size_t, struct dns_svcb *);
+
+DNS_PUBLIC _Bool dns_svcb_getparam(const struct dns_svcb *, enum dns_svcb_key, const unsigned char **, size_t *);
+
+
 /*
  * TXT  R E S O U R C E  R E C O R D
  */
@@ -835,6 +1105,15 @@ union dns_any {
 	struct dns_srv srv;
 	struct dns_opt opt;
 	struct dns_sshfp sshfp;
+	struct dns_ds ds;
+	struct dns_dnskey dnskey;
+	struct dns_rrsig rrsig;
+	struct dns_nsec nsec;
+	struct dns_nsec3 nsec3;
+	struct dns_tlsa tlsa;
+	struct dns_caa caa;
+	struct dns_uri uri;
+	struct dns_svcb svcb, https;
 	struct dns_txt txt, spf, rdata;
 }; /* union dns_any */
 
@@ -919,6 +1198,10 @@ struct dns_resolv_conf {
 			DNS_RESCONF_TCP_ONLY,
 			DNS_RESCONF_TCP_DISABLE,
 		} tcp;
+
+		_Bool ad;  /* RFC 4035: request authenticated data */
+
+		_Bool cd;  /* RFC 4035: disable DNSSEC validation */
 	} options;
 
 	struct sockaddr_storage iface;
@@ -1208,6 +1491,51 @@ DNS_PUBLIC int dns_ai_poll(struct dns_addrinfo *, int);
 DNS_PUBLIC const struct dns_stat *dns_ai_stat(struct dns_addrinfo *);
 
 
+/*
+ * S Y N C H R O N O U S  I N T E R F A C E S
+ *
+ * Blocking wrappers similar to getaddrinfo(3) and getnameinfo(3).
+ *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+ * dns_getaddrinfo - synchronous address resolution (like getaddrinfo)
+ *
+ * Arguments:
+ *   host    - hostname to resolve (required)
+ *   serv    - service name or port number (optional, may be NULL)
+ *   hints   - addrinfo hints (optional, may be NULL)
+ *   res     - output pointer for result list (required)
+ *   timeout - timeout in seconds (0 = no timeout, use internal default)
+ *
+ * Returns 0 on success or an EAI_* error code on failure.
+ * Caller must free *res with dns_freeaddrinfo().
+ */
+DNS_PUBLIC int dns_getaddrinfo(const char *host, const char *serv, const struct addrinfo *hints, struct addrinfo **res, int timeout);
+
+/*
+ * dns_freeaddrinfo - free addrinfo list from dns_getaddrinfo
+ */
+DNS_PUBLIC void dns_freeaddrinfo(struct addrinfo *res);
+
+/*
+ * dns_getnameinfo - synchronous reverse lookup (like getnameinfo)
+ *
+ * Arguments:
+ *   sa      - socket address to look up (required)
+ *   salen   - length of socket address
+ *   host    - buffer for hostname result (may be NULL)
+ *   hostlen - size of host buffer
+ *   serv    - buffer for service result (may be NULL)
+ *   servlen - size of serv buffer
+ *   flags   - NI_* flags (same as getnameinfo)
+ *   timeout - timeout in seconds (0 = no timeout, use internal default)
+ *
+ * Returns 0 on success or an EAI_* error code on failure.
+ */
+DNS_PUBLIC int dns_getnameinfo(const struct sockaddr *sa, socklen_t salen, char *host, size_t hostlen, char *serv, size_t servlen, int flags, int timeout);
+
+
 /*
  * U T I L I T Y  I N T E R F A C E S
  *
diff --git a/src/spf.rl b/src/spf.rl
index 6f6b695..603919b 100644
--- a/src/spf.rl
+++ b/src/spf.rl
@@ -1093,21 +1093,23 @@ static void unknown_comp(struct spf_sbuf *sbuf, struct spf_unknown *unknown) {
 } /* unknown_comp() */
 
 
+typedef void (*spf_term_comp_f)(struct spf_sbuf *, void *);
+
 static const struct {
-	void (*comp)();
+	spf_term_comp_f comp;
 } spf_term[] = {
-	[SPF_ALL]     = { &all_comp },
-	[SPF_INCLUDE] = { &include_comp },
-	[SPF_A]       = { &a_comp },
-	[SPF_MX]      = { &mx_comp },
-	[SPF_PTR]     = { &ptr_comp },
-	[SPF_IP4]     = { &ip4_comp },
-	[SPF_IP6]     = { &ip6_comp },
-	[SPF_EXISTS]  = { &exists_comp },
-
-	[SPF_REDIRECT] = { &redirect_comp },
-	[SPF_EXP]      = { &exp_comp },
-	[SPF_UNKNOWN]  = { &unknown_comp },
+	[SPF_ALL]     = { (spf_term_comp_f)&all_comp },
+	[SPF_INCLUDE] = { (spf_term_comp_f)&include_comp },
+	[SPF_A]       = { (spf_term_comp_f)&a_comp },
+	[SPF_MX]      = { (spf_term_comp_f)&mx_comp },
+	[SPF_PTR]     = { (spf_term_comp_f)&ptr_comp },
+	[SPF_IP4]     = { (spf_term_comp_f)&ip4_comp },
+	[SPF_IP6]     = { (spf_term_comp_f)&ip6_comp },
+	[SPF_EXISTS]  = { (spf_term_comp_f)&exists_comp },
+
+	[SPF_REDIRECT] = { (spf_term_comp_f)&redirect_comp },
+	[SPF_EXP]      = { (spf_term_comp_f)&exp_comp },
+	[SPF_UNKNOWN]  = { (spf_term_comp_f)&unknown_comp },
 }; /* spf_term[] */
 
 static char *term_comp(struct spf_sbuf *sbuf, void *term) {
@@ -1922,7 +1924,7 @@ struct spf_resolver {
 }; /* struct spf_resolver */
 
 
-static void vm_throw() __attribute__((__noreturn__));
+static void vm_throw(struct spf_vm *vm, int error) __attribute__((__noreturn__));
 static void vm_throw(struct spf_vm *vm, int error) {
 	_longjmp(vm->trap, (error)? error : EINVAL);
 } /* vm_throw() */
@@ -4235,7 +4237,8 @@ static struct dns_cache *mkcache(void) {
 	if (!MAIN.cache)
 		return NULL;
 
-	assert(cache = cache_open(&error));
+	cache = cache_open(&error);
+	assert(cache);
 
 	if ((error = cache_loadpath(cache, MAIN.cache, NULL, 0)))
 		panic("%s: %s", MAIN.cache, strerror(error));
@@ -4255,12 +4258,14 @@ static struct dns_resolv_conf *mkresconf(void) {
 		return resconf;
 
 	if (MAIN.resconf) {
-		assert(resconf = dns_resconf_open(&error));
+		resconf = dns_resconf_open(&error);
+		assert(resconf);
 
 		if ((error = dns_resconf_loadpath(resconf, MAIN.resconf)))
 			panic("%s: %s", MAIN.resconf, strerror(error));
 	} else {
-		assert(resconf = dns_resconf_local(&error));
+		resconf = dns_resconf_local(&error);
+		assert(resconf);
 
 		resconf->lookup[2] = resconf->lookup[1];
 		resconf->lookup[1] = resconf->lookup[0];
@@ -4312,10 +4317,13 @@ static int vm(const struct spf_env *env, const char *file) {
 	struct vm_sub sub;
 	int code, error;
 
-	if (file && strcmp(file, "-"))
-		assert((fp = fopen(file, "r")));
+	if (file && strcmp(file, "-")) {
+		fp = fopen(file, "r");
+		assert(fp);
+	}
 
-	assert((spf = spf_open(env, mkres(), NULL, &error)));
+	spf = spf_open(env, mkres(), NULL, &error);
+	assert(spf);
 	vm = &spf->vm;
 	vm->end = 0;
 
@@ -4426,7 +4434,8 @@ static int check(int argc, char *argv[], const struct spf_env *env) {
 	const struct spf_info *info;
 	int error;
 
-	assert((spf = spf_open(env, mkres(), NULL, &error)));
+	spf = spf_open(env, mkres(), NULL, &error);
+	assert(spf);
 
 	while ((error = spf_check(spf))) {
 		switch (error) {