From d2e2fba6d8de6cd2e36d26d93df6ceeee4c694d8 Mon Sep 17 00:00:00 2001
From: Peter Snyder <snyderp@gmail.com>
Date: Thu, 31 Jan 2019 19:43:24 -0800
Subject: [PATCH 01/13] init

---
 .gitignore                 |  2 +
 binding.gyp                |  3 ++
 etld/domain.cc             | 21 ++++++++++
 etld/domain.h              | 45 +++++++++++++++++++++
 etld/etld.cc               | 81 ++++++++++++++++++++++++++++++++++++++
 etld/etld.h                | 64 ++++++++++++++++++++++++++++++
 etld/public_suffix_rule.cc |  0
 etld/public_suffix_rule.h  | 40 +++++++++++++++++++
 etld/types.h               | 19 +++++++++
 test/binding.gyp           |  5 +++
 test/etld_test.cc          | 31 +++++++++++++++
 test/js/matchingTest.js    | 31 +++++++++++++++
 test/protocol_test.cc      |  2 +-
 13 files changed, 343 insertions(+), 1 deletion(-)
 create mode 100644 etld/domain.cc
 create mode 100644 etld/domain.h
 create mode 100644 etld/etld.cc
 create mode 100644 etld/etld.h
 create mode 100644 etld/public_suffix_rule.cc
 create mode 100644 etld/public_suffix_rule.h
 create mode 100644 etld/types.h
 create mode 100644 test/etld_test.cc

diff --git a/.gitignore b/.gitignore
index 71d702c..28dd025 100644
--- a/.gitignore
+++ b/.gitignore
@@ -48,3 +48,5 @@ out
 
 # VIM temp files
 *.swp
+
+.vscode
diff --git a/binding.gyp b/binding.gyp
index fe26fc8..e68ca6d 100644
--- a/binding.gyp
+++ b/binding.gyp
@@ -19,6 +19,9 @@
       "no_fingerprint_domain.h",
       "protocol.cc",
       "protocol.h",
+      "etld/domain.cc",
+      "etld/domain.h",
+      "etld/types.h",
       "./node_modules/bloom-filter-cpp/BloomFilter.cpp",
       "./node_modules/bloom-filter-cpp/BloomFilter.h",
       "./node_modules/bloom-filter-cpp/hashFn.cpp",
diff --git a/etld/domain.cc b/etld/domain.cc
new file mode 100644
index 0000000..367b739
--- /dev/null
+++ b/etld/domain.cc
@@ -0,0 +1,21 @@
+/* Copyright (c) 2015 Brian R. Bondy. Distributed under the MPL2 license.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <string>
+#include "./domain.h"
+
+namespace Brave {
+namespace eTLD {
+
+std::string Domain::toString() const {
+  std::stringstream asString;
+  for (auto &&str : labels_) {
+    asString << str;
+  }
+  return asString.str();
+}
+
+}
+}
\ No newline at end of file
diff --git a/etld/domain.h b/etld/domain.h
new file mode 100644
index 0000000..3af9ba4
--- /dev/null
+++ b/etld/domain.h
@@ -0,0 +1,45 @@
+/* Copyright (c) 2015 Brian R. Bondy. Distributed under the MPL2 license.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef BRAVE_ETLD_DOMAIN_H_
+#define BRAVE_ETLD_DOMAIN_H_
+
+#include <string>
+#include <sstream>
+#include <vector>
+#include "./types.h"
+
+namespace Brave {
+namespace eTLD {
+
+class Domain {
+  public:
+    Domain(const std::string &domain) {
+      std::size_t current, previous = 0;
+      current = domain.find(".");
+      while (current != std::string::npos) {
+          labels_.push_back(domain.substr(previous, current - previous));
+          previous = current + 1;
+          current = domain.find(".", previous);
+      }
+      if (previous != 0) {
+        labels_.push_back(domain.substr(previous, current - previous));
+      }
+    };
+
+    int length() const {
+      return labels_.size();
+    }
+
+    std::string toString() const;
+
+  protected:
+    std::vector<Label> labels_;
+};
+
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/etld/etld.cc b/etld/etld.cc
new file mode 100644
index 0000000..9f59256
--- /dev/null
+++ b/etld/etld.cc
@@ -0,0 +1,81 @@
+/* Copyright (c) 2015 Brian R. Bondy. Distributed under the MPL2 license.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "etld.h"
+#include <iostream>
+#include <string>
+
+using Brave::eTLD::PublicSuffixTextLineType;
+using Brave::eTLD::PublicSuffixTextLineParseResult;
+
+
+namespace Brave {
+namespace eTLD {
+
+
+// PublicSuffixListMatcher::PublicSuffixListMatcher(const char * suffix_list) {
+// }
+
+// This attempts to implement the algorithm described here:
+//   https://www.publicsuffix.org/list/
+PublicSuffixTextLineParseResult parse_public_suffix_text_line(std::string line) {
+  // Check to see if this is a comment line.  If so, process no further.
+  if (line.find("//") == 0) {
+    return PublicSuffixTextLineParseResult(PublicSuffixTextLineTypeComment);
+  }
+
+  size_t first_non_white_space_char = line.find_first_not_of(" ");
+
+  // Next, check to see if the line is only whitespace.
+  if (first_non_white_space_char == std::string::npos) {
+    return PublicSuffixTextLineParseResult(PublicSuffixTextLineTypeWhitespace);
+  }
+
+  if (line.find("!", first_non_white_space_char) == 0) {
+    return PublicSuffixTextLineParseResult(
+      PublicSuffixTextLineTypeException,
+      std::string(line, first_non_white_space_char)
+    );
+  }
+
+  return PublicSuffixTextLineParseResult(
+    PublicSuffixTextLineTypeStandard,
+    std::string(line, first_non_white_space_char)
+  );
+}
+
+} // namespace eTLD
+} // namespace Brave
+
+
+bool testLine(std::string line, PublicSuffixTextLineType type) {
+  PublicSuffixTextLineParseResult result = Brave::eTLD::parse_public_suffix_text_line(std::string(line));
+  if (result.type() != type) {
+    std::cout << "Failed on '" << line << "'" << std::endl;
+    return false;
+  }
+  return true;
+}
+
+
+bool testLineAndRule(std::string line, Brave::eTLD::PublicSuffixTextLineType type, const std::string &expected) {
+  PublicSuffixTextLineParseResult result = Brave::eTLD::parse_public_suffix_text_line(std::string(line));
+  if (result.type() != type) {
+    std::cout << "Failed on '" << line << "'" << std::endl;
+    return false;
+  }
+
+  return result.rule().toString() == expected;
+}
+
+
+
+
+int main() {
+  testLine("// this is comment", Brave::eTLD::PublicSuffixTextLineTypeComment);
+  testLine("      ", Brave::eTLD::PublicSuffixTextLineTypeWhitespace);
+  testLine("!google.com", Brave::eTLD::PublicSuffixTextLineTypeException);
+  return 0;
+}
\ No newline at end of file
diff --git a/etld/etld.h b/etld/etld.h
new file mode 100644
index 0000000..f45bafb
--- /dev/null
+++ b/etld/etld.h
@@ -0,0 +1,64 @@
+/* Copyright (c) 2015 Brian R. Bondy. Distributed under the MPL2 license.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef ETLD_H_
+#define ETLD_H_
+
+#include <string>
+#include <sstream>
+#include <vector>
+
+namespace Brave {
+namespace eTLD {
+
+enum PublicSuffixTextLineType {
+  PublicSuffixTextLineTypeNone = 0,
+  PublicSuffixTextLineTypeWhitespace,
+  PublicSuffixTextLineTypeComment,
+  PublicSuffixTextLineTypeException,
+  PublicSuffixTextLineTypeStandard
+};
+
+typedef std::string Label;
+
+class PublicSuffixTextLineParseResult {
+  public:
+    PublicSuffixTextLineParseResult(PublicSuffixTextLineType type, PublicSuffixRule rule) {
+      type_ = type;
+      rule_ = rule;
+    }
+
+    PublicSuffixTextLineParseResult(PublicSuffixTextLineType type, const std::string &ruleText, bool isException = false) {
+      type_ = type;
+      rule_ = PublicSuffixRule(ruleText, isException);
+    }
+
+    PublicSuffixTextLineParseResult(PublicSuffixTextLineType type) {
+      type_ = type;
+    }
+
+    bool isRule() {
+      return (type_ == PublicSuffixTextLineTypeException || type_ == PublicSuffixTextLineTypeStandard);
+    }
+
+    PublicSuffixTextLineType type() {
+      return type_;
+    }
+
+    PublicSuffixRule rule() {
+      return rule_;
+    }
+
+  private:
+    PublicSuffixTextLineType type_;
+    PublicSuffixRule rule_;
+};
+
+PublicSuffixTextLineParseResult parse_public_suffix_text_line(std::string line);
+
+}
+}
+
+#endif // ELTD_H_
diff --git a/etld/public_suffix_rule.cc b/etld/public_suffix_rule.cc
new file mode 100644
index 0000000..e69de29
diff --git a/etld/public_suffix_rule.h b/etld/public_suffix_rule.h
new file mode 100644
index 0000000..6ce8027
--- /dev/null
+++ b/etld/public_suffix_rule.h
@@ -0,0 +1,40 @@
+/* Copyright (c) 2015 Brian R. Bondy. Distributed under the MPL2 license.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef BRAVE_ETLD_PUBLIC_SUFFIX_RULE_H_
+#define BRAVE_ETLD_PUBLIC_SUFFIX_RULE_H_
+
+#include <string>
+#include <vector>
+#include "./domain.h"
+#include "./types.h"
+
+namespace Brave {
+namespace eTLD {
+
+class PublicSuffixRule {
+  public:
+    PublicSuffixRule(const std::string &raw_text);
+
+    bool matches(const Domain &domain) const;
+    bool isException() const {
+      return is_exception_;
+    };
+    bool isWildcard() const {
+      return is_wildcard_;
+    }
+
+  protected:
+    void parseRule(const std::string &rule_text);
+
+    std::vector<Label> labels_;
+    bool is_exception_;
+    bool is_wildcard_;
+};
+
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/etld/types.h b/etld/types.h
new file mode 100644
index 0000000..97ab210
--- /dev/null
+++ b/etld/types.h
@@ -0,0 +1,19 @@
+/* Copyright (c) 2015 Brian R. Bondy. Distributed under the MPL2 license.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef BRAVE_ETLD_TYPES_H_
+#define BRAVE_ETLD_TYPES_H_
+
+#include <string>
+
+namespace Brave {
+namespace eTLD {
+
+typedef std::string Label;
+
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/test/binding.gyp b/test/binding.gyp
index a2df326..b13fa78 100644
--- a/test/binding.gyp
+++ b/test/binding.gyp
@@ -10,6 +10,7 @@
       "../test/cosmetic_filter_test.cc",
       "../test/protocol_test.cc",
       "../test/orig_filters_test.cc",
+      "../test/etld_test.cc",
       "../test/util.cc",
       "../protocol.cc",
       "../protocol.h",
@@ -25,6 +26,10 @@
       "../filter_list.h",
       "../no_fingerprint_domain.cc",
       "../no_fingerprint_domain.h",
+      "../etld/domain.cc",
+      "../etld/domain.h",
+      "../etld/public_suffix_rule.cc",
+      "../etld/public_suffix_rule.h",
       "../node_modules/bloom-filter-cpp/BloomFilter.cpp",
       "../node_modules/bloom-filter-cpp/BloomFilter.h",
       "../node_modules/bloom-filter-cpp/hashFn.cpp",
diff --git a/test/etld_test.cc b/test/etld_test.cc
new file mode 100644
index 0000000..5805585
--- /dev/null
+++ b/test/etld_test.cc
@@ -0,0 +1,31 @@
+/* Copyright (c) 2015 Brian R. Bondy. Distributed under the MPL2 license.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <string>
+#include <iostream>
+#include <set>
+#include "./CppUnitLite/TestHarness.h"
+#include "./CppUnitLite/Test.h"
+#include "./etld.h"
+
+using std::string;
+using std::cout;
+using std::endl;
+
+using Brave::eTLD::PublicSuffixTextLineType;
+using Brave::eTLD::PublicSuffixTextLineParseResult;
+
+bool testParsePublicSuffixTestLineType(const char * line, PublicSuffixTextLineType expectedType) {
+  PublicSuffixTextLineParseResult result = Brave::eTLD::parse_public_suffix_text_line(string(line));
+  return (result.type() == expectedType);
+}
+
+TEST(publicSuffixTest, basic) {
+  CHECK(testParsePublicSuffixTestLineType(
+      "// this is an option",
+      Brave::eTLD::PublicSuffixTextLineTypeStandard
+    )
+  );
+}
diff --git a/test/js/matchingTest.js b/test/js/matchingTest.js
index f8c9ec9..9645549 100644
--- a/test/js/matchingTest.js
+++ b/test/js/matchingTest.js
@@ -455,4 +455,35 @@ describe('matching', function () {
       })
     })
   })
+
+  describe('third-party match', function () {
+    before(function () {
+      this.client = new AdBlockClient()
+      this.client.parse('||bannersnack.com^$third-party')
+    })
+    it('consider eTLD+1 domains as 1p', function () {
+      const altSubDomainQuery = this.client.findMatchingFilters(
+        'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
+        FilterOptions.script,
+        'www.bannersnack.com'
+      )
+      assert.equal(altSubDomainQuery.matches, false)
+
+      const bareDomainQuery = this.client.findMatchingFilters(
+        'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
+        FilterOptions.script,
+        'bannersnack.com'
+      )
+      assert.equal(bareDomainQuery.matches, false)
+    })
+
+    it('consider non eTLD+1 domains as 3p', function () {
+      const queryResult = this.client.findMatchingFilters(
+        'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
+        FilterOptions.script,
+        'www.example.org'
+      )
+      assert.equal(queryResult.matches, true)
+    })
+  })
 })
diff --git a/test/protocol_test.cc b/test/protocol_test.cc
index 4b4ed31..b68336a 100644
--- a/test/protocol_test.cc
+++ b/test/protocol_test.cc
@@ -43,7 +43,7 @@ TEST(isBlockableProtocol, basic) {
   // blockable protocols.
 
   // To short example
-  CHECK(isBlockableProtocol("htt", 3) == false);
+  CHECK(isBlockableProtocol("htt", 3) == true);
 
   // Bad protocol example.
   CHECK(isBlockableProtocol("htttp://example.com", 25) == false);

From 34812162e22b4a7709a809e80ed4d51e5499a35d Mon Sep 17 00:00:00 2001
From: Peter Snyder <snyderp@gmail.com>
Date: Fri, 1 Feb 2019 17:27:49 -0800
Subject: [PATCH 02/13] Complete initial implementation of using public suffix
 list for eTLD+1

---
 .gitignore                             |     3 +
 Makefile                               |     4 +-
 ad_block_client.cc                     |   139 +-
 ad_block_client.h                      |     6 +-
 ad_block_client_wrap.cc                |    13 +
 ad_block_client_wrap.h                 |     2 +
 binding.gyp                            |    10 +
 brave/BUILD.gn                         |    13 +
 etld/domain.cc                         |    69 +-
 etld/domain.h                          |    60 +-
 etld/etld.cc                           |    81 -
 etld/etld.h                            |    64 -
 etld/matcher.cc                        |   110 +
 etld/matcher.h                         |    55 +
 etld/parser.cc                         |   108 +
 etld/parser.h                          |    68 +
 etld/public_suffix_rule.cc             |   268 +
 etld/public_suffix_rule.h              |    89 +-
 etld/public_suffix_rule_set.cc         |   127 +
 etld/public_suffix_rule_set.h          |    46 +
 etld/serialization.cc                  |    50 +
 etld/serialization.h                   |    34 +
 etld/types.h                           |    23 +-
 filter.cc                              |   115 +-
 filter.h                               |    31 +-
 lib/util.js                            |    40 +-
 muon/BUILD.gn                          |    13 +
 scripts/check.js                       |     8 +
 test/binding.gyp                       |    19 +-
 test/data/public_suffix_list.dat       | 12742 +++++++++++++++++++++++
 test/data/public_suffix_list_short.txt |    52 +
 test/etld_blocking_test.cc             |   258 +
 test/etld_serialization_test.cc        |   170 +
 test/etld_test.cc                      |   543 +-
 test/js/etldTest.js                    |    85 +
 test/js/matchingTest.js                |     3 +
 test/protocol_test.cc                  |     4 +-
 37 files changed, 15180 insertions(+), 345 deletions(-)
 delete mode 100644 etld/etld.cc
 delete mode 100644 etld/etld.h
 create mode 100644 etld/matcher.cc
 create mode 100644 etld/matcher.h
 create mode 100644 etld/parser.cc
 create mode 100644 etld/parser.h
 create mode 100644 etld/public_suffix_rule_set.cc
 create mode 100644 etld/public_suffix_rule_set.h
 create mode 100644 etld/serialization.cc
 create mode 100644 etld/serialization.h
 create mode 100644 test/data/public_suffix_list.dat
 create mode 100644 test/data/public_suffix_list_short.txt
 create mode 100644 test/etld_blocking_test.cc
 create mode 100644 test/etld_serialization_test.cc
 create mode 100644 test/js/etldTest.js

diff --git a/.gitignore b/.gitignore
index 28dd025..f000422 100644
--- a/.gitignore
+++ b/.gitignore
@@ -39,6 +39,9 @@ tags
 # output from sample which can be used for importing
 *.dat
 
+# but do inclule the public_suffix_list.dat file, which is used in tests
+!public_suffix_list.dat
+
 # Python compiled files
 *.pyc
 
diff --git a/Makefile b/Makefile
index 5c48d36..2b3c720 100644
--- a/Makefile
+++ b/Makefile
@@ -5,7 +5,7 @@
 .PHONY: clean
 
 build:
-	 ./node_modules/.bin/node-gyp configure && ./node_modules/.bin/node-gyp build
+	./node_modules/.bin/node-gyp configure && ./node_modules/.bin/node-gyp build
 
 test:
 	./node_modules/node-gyp/gyp/gyp_main.py --generator-output=./build --depth=. -f ninja test/binding.gyp
@@ -26,4 +26,4 @@ perf:
 	./build/out/Default/perf
 
 clean:
-	rm -Rf build
+	rm -Rf build
\ No newline at end of file
diff --git a/ad_block_client.cc b/ad_block_client.cc
index 2c9fa8b..2df8a94 100644
--- a/ad_block_client.cc
+++ b/ad_block_client.cc
@@ -12,6 +12,8 @@
 #include "./cosmetic_filter.h"
 #include "./hashFn.h"
 #include "./no_fingerprint_domain.h"
+#include "etld/matcher.h"
+#include "etld/serialization.h"
 
 #include "BloomFilter.h"
 
@@ -21,6 +23,10 @@ using std::cout;
 using std::endl;
 #endif
 
+using brave_etld::SerializedBuffer;
+using brave_etld::SerializationResult;
+using brave_etld::matcher_from_serialization;
+
 std::set<std::string> unknownOptions;
 
 // Fast hash function applicable to 2 byte char checks
@@ -587,6 +593,10 @@ void AdBlockClient::clear() {
     delete badFingerprintsHashSet;
     badFingerprintsHashSet = nullptr;
   }
+  if (etldMatcher) {
+    delete etldMatcher;
+    etldMatcher = nullptr;
+  }
 
   numFilters = 0;
   numCosmeticFilters = 0;
@@ -685,7 +695,8 @@ bool isNoFingerprintDomainHashSetMiss(HashSet<NoFingerprintDomain> *hashSet,
       static_cast<int>(host + hostLen - start)));
 }
 
-bool isHostAnchoredHashSetMiss(const char *input, int inputLen,
+bool isHostAnchoredHashSetMiss(const AdBlockClient * client,
+    const char *input, int inputLen,
     HashSet<Filter> *hashSet,
     const char *inputHost,
     int inputHostLen,
@@ -709,7 +720,9 @@ bool isHostAnchoredHashSetMiss(const char *input, int inputLen,
     if (*(start - 1) == '.') {
       Filter *filter = hashSet->Find(Filter(start,
             static_cast<int>(inputHost + inputHostLen - start),
-            nullptr, start, inputHostLen - (start - inputHost)));
+            nullptr,
+            start,
+            inputHostLen - (start - inputHost)));
       if (filter && filter->matches(input, inputLen,
             contextOption, contextDomain)) {
         if (foundFilter) {
@@ -722,8 +735,10 @@ bool isHostAnchoredHashSetMiss(const char *input, int inputLen,
   }
 
   Filter *filter = hashSet->Find(Filter(start,
-        static_cast<int>(inputHost + inputHostLen - start), nullptr,
-        start, inputHostLen));
+        static_cast<int>(inputHost + inputHostLen - start),
+        nullptr,
+        start,
+        inputHostLen));
   if (!filter) {
     return true;
   }
@@ -756,7 +771,7 @@ bool AdBlockClient::matches(const char* input, FilterOption contextOption,
   if (contextDomain) {
     contextDomainLen = static_cast<int>(strlen(contextDomain));
     if (isThirdPartyHost(contextDomain, contextDomainLen,
-        inputHost, static_cast<int>(inputHostLen))) {
+        inputHost, static_cast<int>(inputHostLen), etldMatcher)) {
       contextOption =
         static_cast<FilterOption>(contextOption | FOThirdParty);
     } else {
@@ -809,7 +824,7 @@ bool AdBlockClient::matches(const char* input, FilterOption contextOption,
   if (!hasMatch) {
     bloomFilterMiss = bloomFilter
       && !bloomFilter->substringExists(input, AdBlockClient::kFingerprintSize);
-    hostAnchoredHashSetMiss = isHostAnchoredHashSetMiss(input, inputLen,
+    hostAnchoredHashSetMiss = isHostAnchoredHashSetMiss(this, input, inputLen,
         hostAnchoredHashSet, inputHost, inputHostLen,
         contextOption, contextDomain, matchedFilter);
     if (bloomFilterMiss && hostAnchoredHashSetMiss) {
@@ -883,9 +898,9 @@ bool AdBlockClient::matches(const char* input, FilterOption contextOption,
     && !exceptionBloomFilter->substringExists(input,
         AdBlockClient::kFingerprintSize);
   bool hostAnchoredExceptionHashSetMiss =
-    isHostAnchoredHashSetMiss(input, inputLen, hostAnchoredExceptionHashSet,
-        inputHost, inputHostLen, contextOption, contextDomain,
-        matchedExceptionFilter);
+    isHostAnchoredHashSetMiss(this, input, inputLen,
+        hostAnchoredExceptionHashSet, inputHost, inputHostLen,
+        contextOption, contextDomain);
 
   // Now that we have a matching rule, we should check if no exception rule
   // hits, if none hits, we should block
@@ -946,7 +961,7 @@ bool AdBlockClient::findMatchingFilters(const char *input,
   if (contextDomain) {
     contextDomainLen = static_cast<int>(strlen(contextDomain));
     if (isThirdPartyHost(contextDomain, contextDomainLen,
-        inputHost, static_cast<int>(inputHostLen))) {
+        inputHost, static_cast<int>(inputHostLen), etldMatcher)) {
       contextOption =
         static_cast<FilterOption>(contextOption | FOThirdParty);
     } else {
@@ -981,7 +996,7 @@ bool AdBlockClient::findMatchingFilters(const char *input,
   }
 
   if (!*matchingFilter) {
-    isHostAnchoredHashSetMiss(input, inputLen,
+    isHostAnchoredHashSetMiss(this, input, inputLen,
       hostAnchoredHashSet, inputHost, inputHostLen,
       contextOption, contextDomain, matchingFilter);
   }
@@ -1010,9 +1025,9 @@ bool AdBlockClient::findMatchingFilters(const char *input,
   }
 
   if (!*matchingExceptionFilter) {
-    isHostAnchoredHashSetMiss(input, inputLen, hostAnchoredExceptionHashSet,
-        inputHost, inputHostLen, contextOption, contextDomain,
-        matchingExceptionFilter);
+    isHostAnchoredHashSetMiss(this, input, inputLen,
+        hostAnchoredExceptionHashSet, inputHost, inputHostLen, contextOption,
+        contextDomain, matchingExceptionFilter);
   }
 
   if (!*matchingExceptionFilter) {
@@ -1055,7 +1070,7 @@ void setFilterBorrowedMemory(Filter *filters, int numFilters) {
 }
 
 // Parses the filter data into a few collections of filters and enables
-// efficent querying.
+// efficient querying.
 bool AdBlockClient::parse(const char *input, bool preserveRules) {
   // If the user is parsing and we have regex support,
   // then we can determine the fingerprints for the bloom filter.
@@ -1365,6 +1380,7 @@ bool AdBlockClient::parse(const char *input, bool preserveRules) {
           &simpleCosmeticFilters,
           preserveRules);
       if (!f.hasUnsupportedOptions()) {
+        f.setEtldMatcher(etldMatcher);
         switch (f.filterType & FTListTypesMask) {
           case FTException:
             if (f.filterType & FTHostOnly) {
@@ -1441,6 +1457,14 @@ bool AdBlockClient::parse(const char *input, bool preserveRules) {
   return true;
 }
 
+void AdBlockClient::parsePublicSuffixRules(const char *input) {
+  if (etldMatcher != nullptr) {
+    delete etldMatcher;
+  }
+
+  etldMatcher = new Matcher(std::string(input));
+}
+
 // Fills the specified buffer if specified, returns the number of characters
 // written or needed
 int serializeFilters(char * buffer, size_t bufferSizeAvail,
@@ -1542,10 +1566,20 @@ char * AdBlockClient::serialize(int *totalSize,
           &noFingerprintAntiDomainExceptionHashSetSize);
   }
 
+  
+  SerializedBuffer serializedMatcherBuffer;
+  int serializedMatcherBufSize;
+  if (etldMatcher == nullptr) {
+    etldMatcher = new Matcher();
+  }
+  SerializationResult matcherSerializationResult = etldMatcher->Serialize();
+  serializedMatcherBuffer = matcherSerializationResult.buffer;
+  serializedMatcherBufSize = static_cast<int>(serializedMatcherBuffer.size());
+
   // Get the number of bytes that we'll need
   char sz[512];
   *totalSize += 1 + snprintf(sz, sizeof(sz),
-      "%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x",
+      "%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x",
       numFilters,
       numExceptionFilters, adjustedNumCosmeticFilters, adjustedNumHtmlFilters,
       numNoFingerprintFilters, numNoFingerprintExceptionFilters,
@@ -1554,13 +1588,16 @@ char * AdBlockClient::serialize(int *totalSize,
       numNoFingerprintDomainOnlyExceptionFilters,
       numNoFingerprintAntiDomainOnlyExceptionFilters,
       numHostAnchoredFilters, numHostAnchoredExceptionFilters,
-      bloomFilter ? bloomFilter->getByteBufferSize() : 0, exceptionBloomFilter
-        ? exceptionBloomFilter->getByteBufferSize() : 0,
-        hostAnchoredHashSetSize, hostAnchoredExceptionHashSetSize,
-        noFingerprintDomainHashSetSize,
-        noFingerprintAntiDomainHashSetSize,
-        noFingerprintDomainExceptionHashSetSize,
-        noFingerprintAntiDomainExceptionHashSetSize);
+      bloomFilter ? bloomFilter->getByteBufferSize() : 0,
+      exceptionBloomFilter ? exceptionBloomFilter->getByteBufferSize() : 0,
+      hostAnchoredHashSetSize,
+      hostAnchoredExceptionHashSetSize,
+      noFingerprintDomainHashSetSize,
+      noFingerprintAntiDomainHashSetSize,
+      noFingerprintDomainExceptionHashSetSize,
+      noFingerprintAntiDomainExceptionHashSetSize,
+      serializedMatcherBufSize);
+
   *totalSize += serializeFilters(nullptr, 0, filters, numFilters) +
     serializeFilters(nullptr, 0, exceptionFilters, numExceptionFilters) +
     serializeFilters(nullptr, 0, cosmeticFilters, adjustedNumCosmeticFilters) +
@@ -1588,6 +1625,7 @@ char * AdBlockClient::serialize(int *totalSize,
   *totalSize += noFingerprintAntiDomainHashSetSize;
   *totalSize += noFingerprintDomainExceptionHashSetSize;
   *totalSize += noFingerprintAntiDomainExceptionHashSetSize;
+  *totalSize += serializedMatcherBufSize;
 
   // Allocate it
   int pos = 0;
@@ -1667,6 +1705,12 @@ char * AdBlockClient::serialize(int *totalSize,
     delete[] noFingerprintAntiDomainExceptionHashSetBuffer;
   }
 
+  if (serializedMatcherBufSize > 0) {
+    memcpy(buffer + pos, serializedMatcherBuffer.c_str(),
+        serializedMatcherBufSize);
+    pos += serializedMatcherBufSize;
+  }
+
   return buffer;
 }
 
@@ -1717,24 +1761,32 @@ bool AdBlockClient::deserialize(char *buffer) {
       noFingerprintDomainHashSetSize = 0,
       noFingerprintAntiDomainHashSetSize = 0,
       noFingerprintDomainExceptionHashSetSize = 0,
-      noFingerprintAntiDomainExceptionHashSetSize = 0;
+      noFingerprintAntiDomainExceptionHashSetSize = 0,
+      etldMatcherBufSize = 0;
   int pos = 0;
   sscanf(buffer + pos,
-      "%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x",
+      "%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x",
       &numFilters,
-      &numExceptionFilters, &numCosmeticFilters, &numHtmlFilters,
-      &numNoFingerprintFilters, &numNoFingerprintExceptionFilters,
+      &numExceptionFilters,
+      &numCosmeticFilters,
+      &numHtmlFilters,
+      &numNoFingerprintFilters,
+      &numNoFingerprintExceptionFilters,
       &numNoFingerprintDomainOnlyFilters,
       &numNoFingerprintAntiDomainOnlyFilters,
       &numNoFingerprintDomainOnlyExceptionFilters,
       &numNoFingerprintAntiDomainOnlyExceptionFilters,
-      &numHostAnchoredFilters, &numHostAnchoredExceptionFilters,
-      &bloomFilterSize, &exceptionBloomFilterSize,
-      &hostAnchoredHashSetSize, &hostAnchoredExceptionHashSetSize,
+      &numHostAnchoredFilters,
+      &numHostAnchoredExceptionFilters,
+      &bloomFilterSize,
+      &exceptionBloomFilterSize,
+      &hostAnchoredHashSetSize,
+      &hostAnchoredExceptionHashSetSize,
       &noFingerprintDomainHashSetSize,
       &noFingerprintAntiDomainHashSetSize,
       &noFingerprintDomainExceptionHashSetSize,
-      &noFingerprintAntiDomainExceptionHashSetSize);
+      &noFingerprintAntiDomainExceptionHashSetSize,
+      &etldMatcherBufSize);
   pos += static_cast<int>(strlen(buffer + pos)) + 1;
 
   filters = new Filter[numFilters];
@@ -1783,40 +1835,53 @@ bool AdBlockClient::deserialize(char *buffer) {
   pos += exceptionBloomFilterSize;
   if (!initHashSet(&hostAnchoredHashSet,
         buffer + pos, hostAnchoredHashSetSize)) {
-      return false;
+    return false;
   }
   pos += hostAnchoredHashSetSize;
   if (!initHashSet(&hostAnchoredExceptionHashSet,
         buffer + pos, hostAnchoredExceptionHashSetSize)) {
-      return false;
+    return false;
   }
   pos += hostAnchoredExceptionHashSetSize;
 
 
   if (!initHashSet(&noFingerprintDomainHashSet,
         buffer + pos, noFingerprintDomainHashSetSize)) {
-      return false;
+    return false;
   }
   pos += noFingerprintDomainHashSetSize;
 
   if (!initHashSet(&noFingerprintAntiDomainHashSet,
         buffer + pos, noFingerprintAntiDomainHashSetSize)) {
-      return false;
+    return false;
   }
   pos += noFingerprintAntiDomainHashSetSize;
 
   if (!initHashSet(&noFingerprintDomainExceptionHashSet,
         buffer + pos, noFingerprintDomainExceptionHashSetSize)) {
-      return false;
+    return false;
   }
   pos += noFingerprintDomainExceptionHashSetSize;
 
   if (!initHashSet(&noFingerprintAntiDomainExceptionHashSet,
         buffer + pos, noFingerprintAntiDomainExceptionHashSetSize)) {
-      return false;
+    return false;
   }
   pos += noFingerprintAntiDomainExceptionHashSetSize;
 
+  if (etldMatcher != nullptr) {
+    delete etldMatcher;
+  }
+
+  if (etldMatcherBufSize == 0) {
+    etldMatcher = new Matcher();
+  } else {
+    SerializedBuffer serializedmatcherBuffer = std::string(
+      buffer + pos, etldMatcherBufSize);
+    Matcher newMatcher = matcher_from_serialization(serializedmatcherBuffer);
+    etldMatcher = new Matcher(newMatcher);
+  }
+
   return true;
 }
 
diff --git a/ad_block_client.h b/ad_block_client.h
index 5122780..ee11a5f 100644
--- a/ad_block_client.h
+++ b/ad_block_client.h
@@ -9,6 +9,7 @@
 #include <string>
 #include <set>
 #include "./filter.h"
+#include "etld/matcher.h"
 
 class CosmeticFilter;
 class BloomFilter;
@@ -24,9 +25,9 @@ class AdBlockClient {
   ~AdBlockClient();
 
   void clear();
-//   bool parse(const char *input);
   bool parse(const char *input, bool preserveRules = false);
-  bool matches(const char* input,
+  void parsePublicSuffixRules(const char *input);
+  bool matches(const char *input,
       FilterOption contextOption = FONoFilterOption,
       const char* contextDomain = nullptr,
       Filter** matchedFilter = nullptr,
@@ -110,6 +111,7 @@ class AdBlockClient {
   template<class T>
   bool initHashSet(HashSet<T>**, char *buffer, int len);
   char *deserializedBuffer;
+  brave_etld::Matcher* etldMatcher = nullptr;
 };
 
 extern std::set<std::string> unknownOptions;
diff --git a/ad_block_client_wrap.cc b/ad_block_client_wrap.cc
index fe24fa0..93b5721 100644
--- a/ad_block_client_wrap.cc
+++ b/ad_block_client_wrap.cc
@@ -104,6 +104,8 @@ void AdBlockClientWrap::Init(Local<Object> exports) {
   // Prototype
   NODE_SET_PROTOTYPE_METHOD(tpl, "clear", AdBlockClientWrap::Clear);
   NODE_SET_PROTOTYPE_METHOD(tpl, "parse", AdBlockClientWrap::Parse);
+  NODE_SET_PROTOTYPE_METHOD(tpl, "parsePublicSuffixRules",
+      AdBlockClientWrap::ParsePublicSuffixRules);
   NODE_SET_PROTOTYPE_METHOD(tpl, "matches", AdBlockClientWrap::Matches);
   NODE_SET_PROTOTYPE_METHOD(tpl, "findMatchingFilters",
       AdBlockClientWrap::FindMatchingFilters);
@@ -232,6 +234,17 @@ void AdBlockClientWrap::Parse(const FunctionCallbackInfo<Value>& args) {
   obj->parse(buffer, preserveRules);
 }
 
+void AdBlockClientWrap::ParsePublicSuffixRules(
+    const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+  String::Utf8Value str(isolate, args[0]->ToString());
+  const char * buffer = *str;
+
+  AdBlockClientWrap* obj =
+    ObjectWrap::Unwrap<AdBlockClientWrap>(args.Holder());
+  obj->parsePublicSuffixRules(buffer);
+}
+
 void AdBlockClientWrap::Matches(const FunctionCallbackInfo<Value>& args) {
   Isolate* isolate = args.GetIsolate();
   String::Utf8Value str(isolate, args[0]->ToString());
diff --git a/ad_block_client_wrap.h b/ad_block_client_wrap.h
index 3978c5b..53529d0 100644
--- a/ad_block_client_wrap.h
+++ b/ad_block_client_wrap.h
@@ -28,6 +28,8 @@ class AdBlockClientWrap : public AdBlockClient, public node::ObjectWrap {
 
   static void Clear(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Parse(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void ParsePublicSuffixRules(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Matches(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Serialize(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Deserialize(const v8::FunctionCallbackInfo<v8::Value>& args);
diff --git a/binding.gyp b/binding.gyp
index e68ca6d..a260a88 100644
--- a/binding.gyp
+++ b/binding.gyp
@@ -21,6 +21,16 @@
       "protocol.h",
       "etld/domain.cc",
       "etld/domain.h",
+      "etld/matcher.cc",
+      "etld/matcher.h",
+      "etld/parser.cc",
+      "etld/parser.h",
+      "etld/public_suffix_rule_set.cc",
+      "etld/public_suffix_rule_set.h",
+      "etld/public_suffix_rule.cc",
+      "etld/public_suffix_rule.h",
+      "etld/serialization.cc",
+      "etld/serialization.h",
       "etld/types.h",
       "./node_modules/bloom-filter-cpp/BloomFilter.cpp",
       "./node_modules/bloom-filter-cpp/BloomFilter.h",
diff --git a/brave/BUILD.gn b/brave/BUILD.gn
index 37a4ba3..cd219ba 100644
--- a/brave/BUILD.gn
+++ b/brave/BUILD.gn
@@ -26,6 +26,19 @@ source_set("ad-block") {
     "../no_fingerprint_domain.h",
     "../protocol.cc",
     "../protocol.h",
+    "../etld/domain.cc",
+    "../etld/domain.h",
+    "../etld/matcher.cc",
+    "../etld/matcher.h",
+    "../etld/parser.cc",
+    "../etld/parser.h",
+    "../etld/public_suffix_rule.cc",
+    "../etld/public_suffix_rule.h",
+    "../etld/public_suffix_rule_set.cc",
+    "../etld/public_suffix_rule_set.h",
+    "../etld/serialization.cc",
+    "../etld/serialization.h",
+    "../etld/types.h",
   ]
 
   deps = [
diff --git a/etld/domain.cc b/etld/domain.cc
index 367b739..827f24c 100644
--- a/etld/domain.cc
+++ b/etld/domain.cc
@@ -1,21 +1,68 @@
-/* Copyright (c) 2015 Brian R. Bondy. Distributed under the MPL2 license.
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include <string>
-#include "./domain.h"
+#include <sstream>
+#include "etld/domain.h"
 
-namespace Brave {
-namespace eTLD {
+namespace brave_etld {
 
-std::string Domain::toString() const {
-  std::stringstream asString;
-  for (auto &&str : labels_) {
-    asString << str;
+Domain::Domain(const Domain &domain) {
+  labels_ = domain.labels_;
+}
+
+Domain::Domain(const std::string &string) {
+  std::size_t current, previous = 0;
+  current = string.find(".");
+  if (current == std::string::npos) {
+    labels_.push_back(string);
+    return;
+  }
+
+  while (current != std::string::npos) {
+    labels_.push_back(string.substr(previous, current - previous));
+    previous = current + 1;
+    current = string.find(".", previous);
+  }
+
+  if (previous != 0) {
+    labels_.push_back(string.substr(previous, current - previous));
+  }
+}
+
+Domain::Domain(const std::vector<Label> &labels) {
+  labels_ = labels;
+}
+
+bool Domain::Equals(const Domain &domain) {
+  size_t local_length = Length();
+  if (local_length != domain.Length()) {
+    return false;
+  }
+
+  for (size_t i = 0; i < local_length; i += 1) {
+    if (labels_[i].compare(domain.labels_[i]) != 0) {
+      return false;
+    }
   }
-  return asString.str();
+
+  return true;
 }
 
+std::string Domain::ToString() const {
+  std::stringstream as_string;
+  auto num_labels = labels_.size();
+  size_t i = 0;
+  for (auto &str : labels_) {
+    as_string << str;
+    if (i != num_labels - 1) {
+      as_string << ".";
+    }
+    i += 1;
+  }
+  return as_string.str();
 }
-}
\ No newline at end of file
+
+}  // namespace brave_etld
diff --git a/etld/domain.h b/etld/domain.h
index 3af9ba4..a0be563 100644
--- a/etld/domain.h
+++ b/etld/domain.h
@@ -1,45 +1,39 @@
-/* Copyright (c) 2015 Brian R. Bondy. Distributed under the MPL2 license.
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef BRAVE_ETLD_DOMAIN_H_
-#define BRAVE_ETLD_DOMAIN_H_
+#ifndef ETLD_DOMAIN_H_
+#define ETLD_DOMAIN_H_
 
 #include <string>
-#include <sstream>
 #include <vector>
-#include "./types.h"
+#include "etld/types.h"
 
-namespace Brave {
-namespace eTLD {
+namespace brave_etld {
 
 class Domain {
-  public:
-    Domain(const std::string &domain) {
-      std::size_t current, previous = 0;
-      current = domain.find(".");
-      while (current != std::string::npos) {
-          labels_.push_back(domain.substr(previous, current - previous));
-          previous = current + 1;
-          current = domain.find(".", previous);
-      }
-      if (previous != 0) {
-        labels_.push_back(domain.substr(previous, current - previous));
-      }
-    };
-
-    int length() const {
-      return labels_.size();
-    }
-
-    std::string toString() const;
-
-  protected:
-    std::vector<Label> labels_;
+ public:
+  explicit Domain(const Domain &domain);
+  explicit Domain(const std::string &domain);
+  explicit Domain(const std::vector<Label> &labels);
+
+  bool Equals(const Domain &domain);
+
+  size_t Length() const {
+    return labels_.size();
+  }
+
+  Label Get(std::size_t idx) const {
+    return labels_[idx];
+  }
+
+  std::string ToString() const;
+
+ protected:
+  std::vector<Label> labels_;
 };
 
-}
-}
+}  // namespace brave_etld
 
-#endif
\ No newline at end of file
+#endif  // ETLD_DOMAIN_H_
diff --git a/etld/etld.cc b/etld/etld.cc
deleted file mode 100644
index 9f59256..0000000
--- a/etld/etld.cc
+++ /dev/null
@@ -1,81 +0,0 @@
-/* Copyright (c) 2015 Brian R. Bondy. Distributed under the MPL2 license.
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "etld.h"
-#include <iostream>
-#include <string>
-
-using Brave::eTLD::PublicSuffixTextLineType;
-using Brave::eTLD::PublicSuffixTextLineParseResult;
-
-
-namespace Brave {
-namespace eTLD {
-
-
-// PublicSuffixListMatcher::PublicSuffixListMatcher(const char * suffix_list) {
-// }
-
-// This attempts to implement the algorithm described here:
-//   https://www.publicsuffix.org/list/
-PublicSuffixTextLineParseResult parse_public_suffix_text_line(std::string line) {
-  // Check to see if this is a comment line.  If so, process no further.
-  if (line.find("//") == 0) {
-    return PublicSuffixTextLineParseResult(PublicSuffixTextLineTypeComment);
-  }
-
-  size_t first_non_white_space_char = line.find_first_not_of(" ");
-
-  // Next, check to see if the line is only whitespace.
-  if (first_non_white_space_char == std::string::npos) {
-    return PublicSuffixTextLineParseResult(PublicSuffixTextLineTypeWhitespace);
-  }
-
-  if (line.find("!", first_non_white_space_char) == 0) {
-    return PublicSuffixTextLineParseResult(
-      PublicSuffixTextLineTypeException,
-      std::string(line, first_non_white_space_char)
-    );
-  }
-
-  return PublicSuffixTextLineParseResult(
-    PublicSuffixTextLineTypeStandard,
-    std::string(line, first_non_white_space_char)
-  );
-}
-
-} // namespace eTLD
-} // namespace Brave
-
-
-bool testLine(std::string line, PublicSuffixTextLineType type) {
-  PublicSuffixTextLineParseResult result = Brave::eTLD::parse_public_suffix_text_line(std::string(line));
-  if (result.type() != type) {
-    std::cout << "Failed on '" << line << "'" << std::endl;
-    return false;
-  }
-  return true;
-}
-
-
-bool testLineAndRule(std::string line, Brave::eTLD::PublicSuffixTextLineType type, const std::string &expected) {
-  PublicSuffixTextLineParseResult result = Brave::eTLD::parse_public_suffix_text_line(std::string(line));
-  if (result.type() != type) {
-    std::cout << "Failed on '" << line << "'" << std::endl;
-    return false;
-  }
-
-  return result.rule().toString() == expected;
-}
-
-
-
-
-int main() {
-  testLine("// this is comment", Brave::eTLD::PublicSuffixTextLineTypeComment);
-  testLine("      ", Brave::eTLD::PublicSuffixTextLineTypeWhitespace);
-  testLine("!google.com", Brave::eTLD::PublicSuffixTextLineTypeException);
-  return 0;
-}
\ No newline at end of file
diff --git a/etld/etld.h b/etld/etld.h
deleted file mode 100644
index f45bafb..0000000
--- a/etld/etld.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/* Copyright (c) 2015 Brian R. Bondy. Distributed under the MPL2 license.
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef ETLD_H_
-#define ETLD_H_
-
-#include <string>
-#include <sstream>
-#include <vector>
-
-namespace Brave {
-namespace eTLD {
-
-enum PublicSuffixTextLineType {
-  PublicSuffixTextLineTypeNone = 0,
-  PublicSuffixTextLineTypeWhitespace,
-  PublicSuffixTextLineTypeComment,
-  PublicSuffixTextLineTypeException,
-  PublicSuffixTextLineTypeStandard
-};
-
-typedef std::string Label;
-
-class PublicSuffixTextLineParseResult {
-  public:
-    PublicSuffixTextLineParseResult(PublicSuffixTextLineType type, PublicSuffixRule rule) {
-      type_ = type;
-      rule_ = rule;
-    }
-
-    PublicSuffixTextLineParseResult(PublicSuffixTextLineType type, const std::string &ruleText, bool isException = false) {
-      type_ = type;
-      rule_ = PublicSuffixRule(ruleText, isException);
-    }
-
-    PublicSuffixTextLineParseResult(PublicSuffixTextLineType type) {
-      type_ = type;
-    }
-
-    bool isRule() {
-      return (type_ == PublicSuffixTextLineTypeException || type_ == PublicSuffixTextLineTypeStandard);
-    }
-
-    PublicSuffixTextLineType type() {
-      return type_;
-    }
-
-    PublicSuffixRule rule() {
-      return rule_;
-    }
-
-  private:
-    PublicSuffixTextLineType type_;
-    PublicSuffixRule rule_;
-};
-
-PublicSuffixTextLineParseResult parse_public_suffix_text_line(std::string line);
-
-}
-}
-
-#endif // ELTD_H_
diff --git a/etld/matcher.cc b/etld/matcher.cc
new file mode 100644
index 0000000..3d0b80a
--- /dev/null
+++ b/etld/matcher.cc
@@ -0,0 +1,110 @@
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <fstream>
+#include <sstream>
+#include "etld/types.h"
+#include "etld/parser.h"
+#include "etld/public_suffix_rule.h"
+#include "etld/matcher.h"
+#include "etld/types.h"
+#include "etld/serialization.h"
+
+namespace brave_etld {
+
+Matcher::Matcher(std::ifstream &rule_file) {
+  ConsumeParseResult(parse_rule_file(rule_file));
+}
+
+Matcher::Matcher(const std::string &rule_text) {
+  ConsumeParseResult(parse_rule_text(rule_text));
+}
+
+Matcher::Matcher(const PublicSuffixParseResult &rules) {
+  ConsumeParseResult(rules);
+}
+
+Matcher::Matcher(const Matcher &matcher) :
+  rules_(matcher.rules_),
+  exception_rules_(matcher.exception_rules_) {}
+
+Matcher::Matcher(const PublicSuffixRuleSet &rules,
+    const PublicSuffixRuleSet &exception_rules) :
+  rules_(rules),
+  exception_rules_(exception_rules) {}
+
+SerializationResult Matcher::Serialize() const {
+  std::stringstream serialized_buffer;
+  serialized_buffer << rules_.Serialize().buffer;
+  serialized_buffer << exception_rules_.Serialize().buffer;
+
+  const std::string buffer_body = serialized_buffer.str();
+  const size_t body_len = buffer_body.size();
+  const std::string header_str = std::to_string(body_len);
+  const size_t header_len = header_str.size();
+  const size_t body_start = header_len + 1;
+  const size_t buffer_size = body_start + body_len + 1;
+  char buffer[buffer_size];
+
+  snprintf(
+    buffer,
+    buffer_size,
+    "%s:%s",
+    header_str.c_str(),
+    buffer_body.c_str()
+  );
+
+  SerializationResult info;
+  info.body_start = body_start;
+  info.body_len = body_len;
+  info.buffer = buffer;
+  return info;
+}
+
+bool Matcher::Equal(const Matcher &matcher) const {
+  return (rules_.Equal(matcher.rules_) &&
+          exception_rules_.Equal(matcher.exception_rules_));
+}
+
+// Attempts to implement the algoritms described here:
+//   https://publicsuffix.org/list/
+DomainInfo Matcher::Match(const Domain &domain) const {
+  PublicSuffixRuleSetMatchResult except_match = exception_rules_.Match(domain);
+  if (except_match.found_match) {
+    return BuildDomainInfo(except_match.rule, domain);
+  }
+
+  PublicSuffixRuleSetMatchResult rule_match = rules_.Match(domain);
+  if (rule_match.found_match) {
+    return BuildDomainInfo(rule_match.rule, domain);
+  }
+
+  return BuildDomainInfo(PublicSuffixRule("*"), domain);
+}
+
+DomainInfo Matcher::BuildDomainInfo(const PublicSuffixRule &rule,
+    const Domain &domain) const {
+  return rule.Apply(domain);
+}
+
+void Matcher::ConsumeParseResult(const PublicSuffixParseResult &result) {
+  for (auto &elm : result.Rules()) {
+    if (elm.IsException()) {
+      exception_rules_.AddRule(elm);
+    } else {
+      rules_.AddRule(elm);
+    }
+  }
+}
+
+Matcher matcher_from_serialization(const SerializedBuffer &buffer) {
+  SerializedChildBuffers child_buffers = deserialize_buffer(buffer);
+  return {
+    rule_set_from_serialization(child_buffers[0]),
+    rule_set_from_serialization(child_buffers[1])
+  };
+}
+
+}  // namespace brave_etld
diff --git a/etld/matcher.h b/etld/matcher.h
new file mode 100644
index 0000000..a706816
--- /dev/null
+++ b/etld/matcher.h
@@ -0,0 +1,55 @@
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef ETLD_MATCHER_H_
+#define ETLD_MATCHER_H_
+
+#include <string>
+#include <fstream>
+#include <vector>
+#include "etld/domain.h"
+#include "etld/types.h"
+#include "etld/parser.h"
+#include "etld/public_suffix_rule.h"
+#include "etld/public_suffix_rule_set.h"
+#include "etld/serialization.h"
+
+namespace brave_etld {
+
+class Matcher {
+ public:
+  Matcher() {}
+  Matcher(const Matcher &matcher);
+  explicit Matcher(std::ifstream &rule_file);
+  explicit Matcher(const std::string &rule_text);
+  explicit Matcher(const PublicSuffixParseResult &rules);
+  Matcher(const PublicSuffixRuleSet &rules, const PublicSuffixRuleSet &exception_rules);
+
+  SerializationResult Serialize() const;
+
+  bool Equal(const Matcher &matcher) const;
+  void ConsumeParseResult(const PublicSuffixParseResult &result);
+  DomainInfo Match(const Domain &domain) const;
+
+  size_t NumRules() const {
+    return rules_.Rules().size();
+  }
+
+  size_t NumExceptionRules() const {
+    return exception_rules_.Rules().size();
+  }
+
+ private:
+  DomainInfo BuildDomainInfo(const PublicSuffixRule &rule,
+    const Domain &domain) const;
+  PublicSuffixRuleSet rules_;
+  PublicSuffixRuleSet exception_rules_;
+};
+
+Matcher matcher_from_serialization(const SerializedBuffer &buffer);
+
+}  // namespace brave_etld
+
+#endif  // ETLD_MATCHER_H_
diff --git a/etld/parser.cc b/etld/parser.cc
new file mode 100644
index 0000000..0cd9b70
--- /dev/null
+++ b/etld/parser.cc
@@ -0,0 +1,108 @@
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <memory>
+#include <string>
+#include <sstream>
+#include <fstream>
+#include <vector>
+#include "etld/parser.h"
+#include "etld/public_suffix_rule.h"
+#include "etld/types.h"
+
+using std::unique_ptr;
+
+namespace brave_etld {
+
+PublicSuffixParseResult::PublicSuffixParseResult() {}
+
+PublicSuffixParseResult::PublicSuffixParseResult(
+    const PublicSuffixParseResult &results) {
+  num_whitespace_lines_ = results.num_whitespace_lines_;
+  num_comment_lines_ = results.num_comment_lines_;
+  num_invalid_rules_ = results.num_invalid_rules_;
+  rules_ = results.rules_;
+}
+
+std::vector<PublicSuffixRule> PublicSuffixParseResult::Rules() const {
+  return rules_;
+}
+
+void PublicSuffixParseResult::AddParseResult(
+    const PublicSuffixTextLineParseResult &result) {
+  switch (result.type) {
+    case PublicSuffixTextLineTypeRule:
+      rules_.push_back(result.rule);
+      break;
+
+    case PublicSuffixTextLineTypeWhitespace:
+      num_whitespace_lines_ += 1;
+      break;
+
+    case PublicSuffixTextLineTypeComment:
+      num_comment_lines_ += 1;
+      break;
+
+    case PublicSuffixTextLineTypeInvalidRule:
+      num_invalid_rules_ += 1;
+      break;
+
+    case PublicSuffixTextLineTypeNone:
+      break;
+  }
+}
+
+PublicSuffixParseResult parse_rule_file(std::ifstream &rule_file) {
+  std::string line;
+  PublicSuffixParseResult results;
+  PublicSuffixTextLineParseResult line_result;
+  while (std::getline(rule_file, line)) {
+    line_result = parse_rule_line(line);
+    results.AddParseResult(line_result);
+  }
+
+  return results;
+}
+
+PublicSuffixParseResult parse_rule_text(const std::string &text) {
+  std::istringstream stream(text);
+  std::string line;
+  PublicSuffixParseResult results;
+  PublicSuffixTextLineParseResult line_result;
+  while (std::getline(stream, line)) {
+    line_result = parse_rule_line(line);
+    results.AddParseResult(line_result);
+  }
+
+  return results;
+}
+
+PublicSuffixTextLineParseResult parse_rule_line(const std::string &line) {
+  PublicSuffixTextLineParseResult result;
+
+  // Check to see if this is a comment line.  If so, process no further.
+  if (line.find("//") == 0) {
+    result.type = PublicSuffixTextLineTypeComment;
+    return result;
+  }
+
+  std::size_t first_non_white_space_char = line.find_first_not_of(" ");
+  // Next, check to see if the line is only whitespace.
+  if (first_non_white_space_char == std::string::npos) {
+    result.type = PublicSuffixTextLineTypeWhitespace;
+    return result;
+  }
+
+  try {
+    result.rule = PublicSuffixRule(line);
+    result.type = PublicSuffixTextLineTypeRule;
+  } catch (PublicSuffixRuleInputException error) {
+    result.type = PublicSuffixTextLineTypeInvalidRule;
+  }
+
+  return result;
+}
+
+}  // namespace brave_etld
diff --git a/etld/parser.h b/etld/parser.h
new file mode 100644
index 0000000..e4032c4
--- /dev/null
+++ b/etld/parser.h
@@ -0,0 +1,68 @@
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef ETLD_PARSER_H_
+#define ETLD_PARSER_H_
+
+#include <string>
+#include <fstream>
+#include <vector>
+#include "etld/public_suffix_rule.h"
+#include "etld/types.h"
+
+namespace brave_etld {
+
+enum PublicSuffixTextLineType {
+  PublicSuffixTextLineTypeNone = 0,
+  PublicSuffixTextLineTypeWhitespace,
+  PublicSuffixTextLineTypeComment,
+  PublicSuffixTextLineTypeInvalidRule,
+  PublicSuffixTextLineTypeRule,
+};
+
+struct PublicSuffixTextLineParseResult {
+  PublicSuffixTextLineParseResult() {
+    type = PublicSuffixTextLineTypeNone;
+  }
+  PublicSuffixTextLineType type;
+  PublicSuffixRule rule;
+};
+
+class PublicSuffixParseResult {
+ public:
+  PublicSuffixParseResult();
+  PublicSuffixParseResult(const PublicSuffixParseResult &results);
+
+  std::vector<PublicSuffixRule> Rules() const;
+  void AddParseResult(const PublicSuffixTextLineParseResult &result);
+
+  int NumWhitespaceLines() const {
+    return num_whitespace_lines_;
+  }
+
+  int NumCommentLines() const {
+    return num_comment_lines_;
+  }
+
+  int NumInvalidRules() const {
+    return num_invalid_rules_;
+  }
+
+ private:
+  int num_whitespace_lines_ = 0;
+  int num_comment_lines_ = 0;
+  int num_invalid_rules_ = 0;
+  std::vector<PublicSuffixRule> rules_;
+};
+
+// This attempts to implement the algorithm described here:
+//   https://www.publicsuffix.org/list/
+PublicSuffixParseResult parse_rule_file(std::ifstream &rule_file);
+PublicSuffixParseResult parse_rule_text(const std::string &rule_text);
+PublicSuffixTextLineParseResult parse_rule_line(const std::string &line);
+
+}  // namespace brave_etld
+
+#endif  // ETLD_PARSER_H_
diff --git a/etld/public_suffix_rule.cc b/etld/public_suffix_rule.cc
index e69de29..4f83844 100644
--- a/etld/public_suffix_rule.cc
+++ b/etld/public_suffix_rule.cc
@@ -0,0 +1,268 @@
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <string>
+#include <sstream>
+#include <vector>
+#include <cstdio>
+#include <iostream>
+#include "etld/domain.h"
+#include "etld/public_suffix_rule.h"
+#include "etld/types.h"
+#include "etld/serialization.h"
+
+using std::unique_ptr;
+
+namespace brave_etld {
+
+std::vector<Label> parse_labels(const std::string &label_text) {
+  std::vector<Label> labels;
+  size_t previous = 0;
+  size_t current = label_text.find(".");
+  Label current_label;
+  while (current != std::string::npos) {
+    current_label = label_text.substr(previous, current - previous);
+    if (current_label.length() == 0) {
+      throw PublicSuffixRuleInputException(
+        "Rules cannot contain adjectent delimitors: " + label_text);
+    }
+    labels.push_back(current_label);
+    previous = current + 1;
+    current = label_text.find(".", previous);
+  }
+
+  // If don't include any trailing whitespace, if there is any.
+  current_label = label_text.substr(previous, current - previous);
+  if (current_label == "") {
+    throw PublicSuffixRuleInputException(
+      "Rules cannot end with a delimiter: " + label_text);
+  }
+
+  labels.push_back(current_label);
+  return labels;
+}
+
+// Cargo-cult-ed from https://codereview.stackexchange.com/questions/40124/trim-white-space-from-string
+std::string trim_to_whitespace(std::string const& str) {
+  if (str.empty()) {
+    return str;
+  }
+
+  std::size_t first_scan = str.find_first_of(' ');
+  if (first_scan == std::string::npos) {
+    return str;
+  }
+
+  return str.substr(0, first_scan);
+}
+
+PublicSuffixRule::PublicSuffixRule() {
+  labels_ = std::vector<Label>();
+  is_exception_ = false;
+  is_wildcard_ = false;
+}
+
+PublicSuffixRule::PublicSuffixRule(const PublicSuffixRule &rule) {
+  labels_ = rule.Labels();
+  is_exception_ = rule.IsException();
+  is_wildcard_ = rule.IsWildcard();
+}
+
+PublicSuffixRule::PublicSuffixRule(const std::string &rule_text) {
+  std::string trimmed_rule_text(trim_to_whitespace(rule_text));
+  if (trimmed_rule_text.length() == 0) {
+    throw PublicSuffixRuleInputException(
+      "Cannot create PublicSuffixRule from an empty string");
+  }
+
+  std::size_t current = 0;
+  switch (trimmed_rule_text[0]) {
+    case '*':
+      is_wildcard_ = true;
+      break;
+
+    case '!':
+      is_exception_ = true;
+      current += 1;
+      break;
+
+    case '/':
+      throw PublicSuffixRuleInputException(
+        "Rules cannot start with '/': " + rule_text);
+      break;
+
+    default:
+      break;
+  }
+
+  std::string labels_view(trimmed_rule_text, current);
+  labels_ = parse_labels(labels_view);
+}
+
+PublicSuffixRule::PublicSuffixRule(const std::vector<Label> &labels,
+  bool is_exception, bool is_wildcard) :
+    labels_(labels),
+    is_exception_(is_exception),
+    is_wildcard_(is_wildcard) {
+}
+
+SerializationResult PublicSuffixRule::Serialize() const {
+  SerializationResult info;
+  const std::string domain_string = DomainString();
+  const size_t body_len = domain_string.size() + 2;
+  const std::string header_str = std::to_string(body_len);
+  const size_t header_len = header_str.size();
+  const size_t body_start = header_len + 1;
+  const uint buffer_size = body_start + body_len + 1;
+  char buffer[buffer_size];
+
+  snprintf(
+    buffer,
+    buffer_size,
+    "%s:%c%c%s",
+    header_str.c_str(),
+    is_exception_ ? 't' : 'f',
+    is_wildcard_ ? 't' : 'f',
+    domain_string.c_str()
+  );
+
+  info.body_start = body_start;
+  info.body_len = body_len;
+  info.buffer = buffer;
+  return info;
+}
+
+bool PublicSuffixRule::Equals(const PublicSuffixRule &rule) const {
+  return (
+    labels_ == rule.Labels() &&
+    is_exception_ == rule.IsException() &&
+    is_wildcard_ == rule.IsWildcard());
+}
+
+// Implements matching algoritms described here
+//   https://publicsuffix.org/list/
+bool PublicSuffixRule::Matches(const Domain &domain) const {
+  // When the domain and rule are split into corresponding labels, that the
+  // domain contains as many or more labels than the rule.
+  auto num_rule_labels = labels_.size();
+  auto num_domain_labels = domain.Length();
+  if (num_rule_labels > num_domain_labels) {
+    return false;
+  }
+
+  // Beginning with the right-most labels of both the domain and the rule, and
+  // continuing for all labels in the rule, one finds that for every pair,
+  // either they are identical, or that the label from the rule is "*".
+  for (size_t i = 0; i < num_rule_labels; i += 1) {
+    Label rule_label = labels_[num_rule_labels - i - 1];
+    Label domain_label = domain.Get(num_domain_labels - i - 1);
+
+    if (rule_label == "*") {
+      continue;
+    }
+
+    if (rule_label != domain_label) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+DomainInfo PublicSuffixRule::Apply(const Domain &domain) const {
+  DomainInfo domain_info;
+
+  auto domain_len = domain.Length();
+  auto rule_len = Length();
+  if (IsException()) {
+    rule_len -= 1;
+  }
+
+  auto tld_seg_len = rule_len;
+  std::stringstream tld_seg;
+
+  auto domain_seg_len = (tld_seg_len == domain_len) ? 0 : 1;
+  std::stringstream domain_seg;
+
+  auto sub_domain_seg_len = domain_len - domain_seg_len - tld_seg_len;
+  std::stringstream sub_domain_seg;
+
+  Label domain_label;
+  for (size_t i = 0; i < domain_len; i += 1) {
+    domain_label = domain.Get(i);
+
+    if (sub_domain_seg_len > 0) {
+      sub_domain_seg_len -= 1;
+      sub_domain_seg << domain_label;
+      if (sub_domain_seg_len != 0) {
+        sub_domain_seg << ".";
+      }
+      continue;
+    }
+
+    if (domain_seg_len > 0) {
+      domain_seg_len -= 1;
+      domain_seg << domain_label;
+      if (domain_seg_len != 0) {
+        domain_seg << ".";
+      }
+      continue;
+    }
+
+    tld_seg_len -= 1;
+    tld_seg << domain_label;
+    if (tld_seg_len != 0) {
+      tld_seg << ".";
+    }
+  }
+
+  domain_info.tld = tld_seg.str();
+  domain_info.domain = domain_seg.str();
+  domain_info.subdomain = sub_domain_seg.str();
+  return domain_info;
+}
+
+std::string PublicSuffixRule::DomainString() const {
+  auto last_label_index = labels_.size() - 1;
+  size_t label_index = 0;
+  std::stringstream as_string;
+  for (auto &elm : labels_) {
+    as_string << elm;
+    if (label_index != last_label_index) {
+      as_string << ".";
+    }
+    label_index += 1;
+  }
+
+  return as_string.str();
+}
+
+std::vector<Label> PublicSuffixRule::Labels() const {
+  return labels_;
+}
+
+size_t PublicSuffixRule::Length() const {
+  return labels_.size();
+}
+
+std::string PublicSuffixRule::ToString() const {
+  std::stringstream as_string;
+  as_string << "labels: [" << DomainString() << "] ";
+  as_string << "is exception: " << (is_exception_ ? "true" : "false") << " ";
+  as_string << "is wildcard: " << (is_wildcard_ ? "true" : "false");
+  return as_string.str();
+}
+
+PublicSuffixRule rule_from_serialization(const SerializedBuffer &buffer) {
+  const SerializedBufferInfo info = extract_buffer_info(buffer);
+  const std::string body_str = buffer.substr(info.body_start, info.body_len);
+  bool is_exception = body_str[0] == 't';
+  bool is_wildcard = body_str[1] == 't';
+  const std::string label_str(body_str, 2, info.body_len - 2);
+  std::vector<Label> labels = parse_labels(label_str);
+  return PublicSuffixRule(labels, is_exception, is_wildcard);
+}
+
+}  // namespace brave_etld
diff --git a/etld/public_suffix_rule.h b/etld/public_suffix_rule.h
index 6ce8027..7739548 100644
--- a/etld/public_suffix_rule.h
+++ b/etld/public_suffix_rule.h
@@ -1,40 +1,73 @@
-/* Copyright (c) 2015 Brian R. Bondy. Distributed under the MPL2 license.
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef BRAVE_ETLD_PUBLIC_SUFFIX_RULE_H_
-#define BRAVE_ETLD_PUBLIC_SUFFIX_RULE_H_
+#ifndef ETLD_PUBLIC_SUFFIX_RULE_H_
+#define ETLD_PUBLIC_SUFFIX_RULE_H_
 
 #include <string>
 #include <vector>
-#include "./domain.h"
-#include "./types.h"
+#include "etld/domain.h"
+#include "etld/types.h"
+#include "etld/serialization.h"
 
-namespace Brave {
-namespace eTLD {
+using std::unique_ptr;
+
+namespace brave_etld {
+
+class PublicSuffixRuleInputException : public std::exception {
+ public:
+  explicit PublicSuffixRuleInputException(const char * message) :
+    msg_(message) {}
+  explicit PublicSuffixRuleInputException(const std::string &message) :
+    msg_(message) {}
+  virtual const char* what() const throw() {
+    return msg_.c_str();
+  }
+  virtual ~PublicSuffixRuleInputException() throw() {}
+
+ protected:
+  std::string msg_;
+};
 
 class PublicSuffixRule {
-  public:
-    PublicSuffixRule(const std::string &raw_text);
-
-    bool matches(const Domain &domain) const;
-    bool isException() const {
-      return is_exception_;
-    };
-    bool isWildcard() const {
-      return is_wildcard_;
-    }
-
-  protected:
-    void parseRule(const std::string &rule_text);
-
-    std::vector<Label> labels_;
-    bool is_exception_;
-    bool is_wildcard_;
+ public:
+  PublicSuffixRule();
+  PublicSuffixRule(const PublicSuffixRule &rule);
+  explicit PublicSuffixRule(const std::string &rule_text);
+  PublicSuffixRule(
+    const std::vector<Label> &labels,
+    bool is_exception = false,
+    bool is_wildcard = false);
+
+  SerializationResult Serialize() const;
+
+  bool Equals(const PublicSuffixRule &rule) const;
+  bool Matches(const Domain &domain) const;
+  DomainInfo Apply(const Domain &domain) const;
+  std::string ToString() const;
+  std::string DomainString() const;
+
+  std::vector<Label> Labels() const;
+  size_t Length() const;
+
+  bool IsException() const {
+    return is_exception_;
+  }
+  bool IsWildcard() const {
+    return is_wildcard_;
+  }
+
+ protected:
+  std::vector<Label> labels_;
+  bool is_exception_ = false;
+  bool is_wildcard_ = false;
 };
 
-}
-}
+PublicSuffixRule rule_from_serialization(const SerializedBuffer &buffer);
+std::vector<Label> parse_labels(const std::string &label_text);
+
+}  // namespace brave_etld
 
-#endif
\ No newline at end of file
+#endif  // ETLD_PUBLIC_SUFFIX_RULE_H_
diff --git a/etld/public_suffix_rule_set.cc b/etld/public_suffix_rule_set.cc
new file mode 100644
index 0000000..c685553
--- /dev/null
+++ b/etld/public_suffix_rule_set.cc
@@ -0,0 +1,127 @@
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <string>
+#include <sstream>
+#include <vector>
+#include <memory>
+#include <iostream>
+#include "etld/public_suffix_rule.h"
+#include "etld/public_suffix_rule_set.h"
+#include "etld/domain.h"
+#include "etld/types.h"
+#include "etld/serialization.h"
+
+using std::unique_ptr;
+
+namespace brave_etld {
+
+PublicSuffixRuleSet::PublicSuffixRuleSet() {}
+
+PublicSuffixRuleSet::PublicSuffixRuleSet(const PublicSuffixRuleSet &rule_set) {
+  rules_ = rule_set.Rules();
+}
+
+PublicSuffixRuleSet::PublicSuffixRuleSet(
+    const std::vector<PublicSuffixRule> &rules) {
+  rules_ = rules;
+}
+
+bool PublicSuffixRuleSet::Equal(const PublicSuffixRuleSet &rule_set) const {
+  if (rules_.size() != rule_set.rules_.size()) {
+    return false;
+  }
+
+  bool found_match;
+  for (auto &local_elm : rules_) {
+    found_match = false;
+    for (auto &other_elm : rule_set.rules_) {
+     if (local_elm.Equals(other_elm)) {
+       found_match = true;
+       break;
+     }
+    }
+    if (!found_match) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+SerializationResult PublicSuffixRuleSet::Serialize() const {
+  std::stringstream serialized_buffer;
+  for (auto &elm : rules_) {
+    serialized_buffer << elm.Serialize().buffer;
+  }
+
+  const std::string buffer_body = serialized_buffer.str();
+  const size_t body_len = buffer_body.size();
+  const std::string header_str = std::to_string(body_len);
+  const size_t header_len = header_str.size();
+  const size_t body_start = header_len + 1;
+  const size_t buffer_size = body_start + body_len + 1;
+  char buffer[buffer_size];
+
+  snprintf(
+    buffer,
+    buffer_size,
+    "%s:%s",
+    header_str.c_str(),
+    buffer_body.c_str()
+  );
+
+  SerializationResult info;
+  info.body_start = body_start;
+  info.body_len = body_len;
+  info.buffer = buffer;
+  return info;
+}
+
+PublicSuffixRuleSetMatchResult PublicSuffixRuleSet::Match(
+    const Domain &domain) const {
+  int longest_length = -1;
+  int found_length;
+  PublicSuffixRule longest_rule;
+  for (auto &elm : rules_) {
+    if (elm.Matches(domain)) {
+      found_length = elm.Labels().size();
+      if (found_length > longest_length) {
+        longest_rule = elm;
+        longest_length = found_length;
+      }
+    }
+  }
+
+  PublicSuffixRuleSetMatchResult result;
+
+  if (longest_length == -1) {
+    result.found_match = false;
+    return result;
+  }
+
+  result.found_match = true;
+  result.rule = longest_rule;
+  return result;
+}
+
+void PublicSuffixRuleSet::AddRule(const PublicSuffixRule &rule) {
+  rules_.push_back(rule);
+}
+
+std::vector<PublicSuffixRule> PublicSuffixRuleSet::Rules() const {
+  return rules_;
+}
+
+PublicSuffixRuleSet rule_set_from_serialization(
+    const SerializedBuffer &buffer) {
+  std::vector<PublicSuffixRule> rules;
+  for (auto &elm : deserialize_buffer(buffer)) {
+    rules.push_back(rule_from_serialization(elm));
+  }
+  return PublicSuffixRuleSet(rules);
+}
+
+}  // namespace brave_etld
diff --git a/etld/public_suffix_rule_set.h b/etld/public_suffix_rule_set.h
new file mode 100644
index 0000000..47aa47a
--- /dev/null
+++ b/etld/public_suffix_rule_set.h
@@ -0,0 +1,46 @@
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef ETLD_PUBLIC_SUFFIX_RULE_SET_H_
+#define ETLD_PUBLIC_SUFFIX_RULE_SET_H_
+
+#include <string>
+#include <vector>
+#include <memory>
+#include "etld/public_suffix_rule.h"
+#include "etld/domain.h"
+#include "etld/types.h"
+#include "etld/serialization.h"
+
+using std::unique_ptr;
+
+namespace brave_etld {
+
+struct PublicSuffixRuleSetMatchResult {
+  bool found_match;
+  PublicSuffixRule rule;
+};
+
+class PublicSuffixRuleSet {
+ public:
+  PublicSuffixRuleSet();
+  PublicSuffixRuleSet(const std::vector<PublicSuffixRule> &rules);
+  PublicSuffixRuleSet(const PublicSuffixRuleSet &rule_set);
+
+  SerializationResult Serialize() const;
+  bool Equal(const PublicSuffixRuleSet &rule_set) const;
+  PublicSuffixRuleSetMatchResult Match(const Domain &domain) const;
+  void AddRule(const PublicSuffixRule &rule);
+  std::vector<PublicSuffixRule> Rules() const;
+
+ private:
+  std::vector<PublicSuffixRule> rules_;
+};
+
+PublicSuffixRuleSet rule_set_from_serialization(const SerializedBuffer &buffer);
+
+}  // namespace brave_etld
+
+#endif  // ETLD_PUBLIC_SUFFIX_RULE_SET_H_
diff --git a/etld/serialization.cc b/etld/serialization.cc
new file mode 100644
index 0000000..cba5f88
--- /dev/null
+++ b/etld/serialization.cc
@@ -0,0 +1,50 @@
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <iostream>
+#include <vector>
+#include <string>
+#include "etld/serialization.h"
+
+namespace brave_etld {
+
+SerializedBufferInfo extract_buffer_info(const SerializedBuffer &buffer) {
+  SerializedBufferInfo info;
+  const size_t splitter_pos = buffer.find(":");
+  if (splitter_pos == std::string::npos) {
+    info.body_len = std::string::npos;
+    info.body_start = std::string::npos;
+    info.buffer_len = 0;
+    return info;
+  }
+
+  const std::string header_str = buffer.substr(0, splitter_pos);
+  info.body_start = splitter_pos + 1;
+  info.body_len = std::stoi(header_str);
+  info.buffer_len = info.body_start + info.body_len;
+  return info;
+}
+
+SerializedChildBuffers deserialize_buffer(const SerializedBuffer &buffer) {
+  std::vector<SerializedBuffer> child_buffers;
+  SerializedBufferInfo info = extract_buffer_info(buffer);
+  if (info.body_len == std::string::npos) {
+    return child_buffers;
+  }
+
+  const size_t payload_len = buffer.size();
+  size_t offset = info.body_start;
+  std::string child_buffer;
+  while (offset < payload_len) {
+    info = extract_buffer_info(buffer.substr(offset, payload_len - offset));
+    child_buffer = buffer.substr(offset, info.buffer_len);
+    child_buffers.push_back(child_buffer);
+    offset += info.buffer_len;
+  }
+
+  return child_buffers;
+}
+
+}  // namespace brave_etld
diff --git a/etld/serialization.h b/etld/serialization.h
new file mode 100644
index 0000000..5233a9a
--- /dev/null
+++ b/etld/serialization.h
@@ -0,0 +1,34 @@
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef ETLD_SERIALIZATION_H_
+#define ETLD_SERIALIZATION_H_
+
+#include <string>
+#include <vector>
+
+namespace brave_etld {
+
+typedef std::string SerializedBuffer;
+typedef std::vector<SerializedBuffer> SerializedChildBuffers;
+
+struct SerializedBufferInfo {
+  size_t body_len;
+  size_t body_start;
+  size_t buffer_len;
+};
+
+struct SerializationResult {
+  SerializedBuffer buffer;
+  size_t body_len;
+  size_t body_start;
+};
+
+SerializedBufferInfo extract_buffer_info(const SerializedBuffer &buffer);
+SerializedChildBuffers deserialize_buffer(const SerializedBuffer &buffer);
+
+}  // namespace brave_etld
+
+#endif  // ETLD_SERIALIZATION_H_
diff --git a/etld/types.h b/etld/types.h
index 97ab210..64105da 100644
--- a/etld/types.h
+++ b/etld/types.h
@@ -1,19 +1,24 @@
-/* Copyright (c) 2015 Brian R. Bondy. Distributed under the MPL2 license.
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef BRAVE_ETLD_TYPES_H_
-#define BRAVE_ETLD_TYPES_H_
+#ifndef ETLD_TYPES_H_
+#define ETLD_TYPES_H_
 
 #include <string>
+#include <vector>
 
-namespace Brave {
-namespace eTLD {
+namespace brave_etld {
 
 typedef std::string Label;
 
-}
-}
+struct DomainInfo {
+  std::string tld;
+  std::string domain;
+  std::string subdomain;
+};
 
-#endif
\ No newline at end of file
+}  // namespace brave_etld
+
+#endif  // ETLD_TYPES_H_
diff --git a/filter.cc b/filter.cc
index 5fb7fc5..9f05c49 100644
--- a/filter.cc
+++ b/filter.cc
@@ -9,6 +9,7 @@
 #include <iostream>
 #include <set>
 #include <string>
+#include "etld/matcher.h"
 
 #ifdef ENABLE_REGEX
 #include <regex> // NOLINT
@@ -23,23 +24,28 @@
 
 static HashFn h(19);
 
+using brave_etld::Domain;
+using brave_etld::Matcher;
+using brave_etld::DomainInfo;
+
+bool Filter::has_psl_warned = false;
+
 const char * getUrlHost(const char *input, int *len);
 
 Filter::Filter() :
-  borrowed_data(false),
-  filterType(FTNoFilterType),
-  filterOption(FONoFilterOption),
-  antiFilterOption(FONoFilterOption),
-  ruleDefinition(nullptr),
-  data(nullptr),
-  dataLen(-1),
-  domainList(nullptr),
-  host(nullptr),
-  hostLen(-1),
-  domains(nullptr),
-  antiDomains(nullptr),
-  domainsParsed(false) {
-}
+    borrowed_data(false),
+    filterType(FTNoFilterType),
+    filterOption(FONoFilterOption),
+    antiFilterOption(FONoFilterOption),
+    ruleDefinition(nullptr),
+    data(nullptr),
+    dataLen(-1),
+    domainList(nullptr),
+    host(nullptr),
+    hostLen(-1),
+    domains(nullptr),
+    antiDomains(nullptr),
+    domainsParsed(false) {}
 
 Filter::~Filter() {
   if (domains) {
@@ -66,22 +72,21 @@ Filter::~Filter() {
 
 Filter::Filter(const char * data, int dataLen, char *domainList,
                const char * host, int hostLen) :
-      borrowed_data(true), filterType(FTNoFilterType),
-      filterOption(FONoFilterOption),
-      antiFilterOption(FONoFilterOption), ruleDefinition(nullptr),
-      data(const_cast<char*>(data)), dataLen(dataLen),
-      domainList(domainList), host(const_cast<char*>(host)),
-      hostLen(hostLen),
-      domains(nullptr),
-      antiDomains(nullptr),
-      domainsParsed(false) {
-  }
+    borrowed_data(true), filterType(FTNoFilterType),
+    filterOption(FONoFilterOption),
+    antiFilterOption(FONoFilterOption), ruleDefinition(nullptr),
+    data(const_cast<char*>(data)), dataLen(dataLen),
+    domainList(domainList), host(const_cast<char*>(host)),
+    hostLen(hostLen),
+    domains(nullptr),
+    antiDomains(nullptr),
+    domainsParsed(false),
+    etldMatcher(nullptr) {}
 
 Filter::Filter(FilterType filterType, FilterOption filterOption,
                FilterOption antiFilterOption,
-               const char * data, int dataLen,
-               char *domainList, const char * host,
-               int hostLen) :
+               const char * data, int dataLen, char *domainList,
+               const char * host, int hostLen) :
       borrowed_data(true), filterType(filterType),
       filterOption(filterOption),
       antiFilterOption(antiFilterOption), ruleDefinition(nullptr),
@@ -90,8 +95,8 @@ Filter::Filter(FilterType filterType, FilterOption filterOption,
       hostLen(hostLen),
       domains(nullptr),
       antiDomains(nullptr),
-      domainsParsed(false) {
-  }
+      domainsParsed(false),
+      etldMatcher(nullptr) {}
 
 Filter::Filter(const Filter &other) {
   borrowed_data = other.borrowed_data;
@@ -103,6 +108,8 @@ Filter::Filter(const Filter &other) {
   domainsParsed = false;
   domains = nullptr;
   antiDomains = nullptr;
+  setEtldMatcher(other.etldMatcher);
+
   if (other.dataLen == -1 && other.data) {
     dataLen = static_cast<int>(strlen(other.data));
   }
@@ -342,18 +349,54 @@ bool endsWith(const char *input, const char *sub, int inputLen, int subLen) {
 }
 
 bool isThirdPartyHost(const char *baseContextHost, int baseContextHostLen,
-    const char *testHost, int testHostLen) {
-  if (!endsWith(testHost, baseContextHost, testHostLen, baseContextHostLen)) {
+    const char *testHost, int testHostLen, Matcher * matcher) {
+  std::string baseDomainStr(baseContextHost, baseContextHostLen);
+  Domain baseDomain(baseDomainStr);
+  std::string testDomainStr(testHost, testHostLen);
+  Domain testDomain(testDomainStr);
+
+  if (matcher == nullptr) {
+    if (Filter::has_psl_warned == false) {
+      std::cerr << "!!! Attempting to determine third-party-ness without a "
+                << "parsed Public Suffix List.  Falling back to FQDN, results "
+                << "will be less accurate.\n";
+      Filter::has_psl_warned = true;
+    }
+    return !baseDomain.Equals(testDomain);
+  }
+
+  DomainInfo baseHostDomainInfo = matcher->Match(baseDomain);
+  DomainInfo testHostDomainInfo = matcher->Match(testDomain);
+
+  if (baseHostDomainInfo.tld != testHostDomainInfo.tld ||
+      baseHostDomainInfo.domain != testHostDomainInfo.domain) {
     return true;
   }
 
-  // baseContextHost matches testHost exactly
-  if (testHostLen == baseContextHostLen) {
+  return false;
+}
+
+bool isMatchingHostAnchor(const char *ruleHost, int ruleHostLen,
+    const char *testHost, int testHostLen) {
+  std::string ruleHostStr(ruleHost, ruleHostLen);
+  std::string testHostStr(testHost, testHostLen);
+  size_t lastSubstrIndex = testHostStr.rfind(ruleHostStr);
+  if (lastSubstrIndex == std::string::npos) {
     return false;
   }
 
-  char c = testHost[testHostLen - baseContextHostLen - 1];
-  return c != '.' && testHostLen != baseContextHostLen;
+  // If the domain in the rule does not appear at the end of the given
+  // host, then do not process further.
+  if (static_cast<int>(lastSubstrIndex) + ruleHostLen != testHostLen) {
+    return false;
+  }
+
+  // Finally, check and make sure that the domain in the rule is preceeded by
+  // either a "." or is the first character in the string.
+  if (lastSubstrIndex == 0 || testHostStr[lastSubstrIndex - 1] == '.') {
+    return true;
+  }
+  return false;
 }
 
 bool Filter::hasUnsupportedOptions() const {
@@ -583,7 +626,7 @@ bool Filter::matches(const char *input, int inputLen,
       }
     }
 
-    if (isThirdPartyHost(host, hostLen, currentHost, currentHostLen)) {
+    if (!isMatchingHostAnchor(host, hostLen, currentHost, currentHostLen)) {
       return false;
     }
   }
diff --git a/filter.h b/filter.h
index 8fff2a6..a4d0309 100644
--- a/filter.h
+++ b/filter.h
@@ -10,10 +10,14 @@
 #include <string.h>
 #include "./base.h"
 #include "./context_domain.h"
+#include "etld/matcher.h"
 
 class BloomFilter;
+class AdBlockClient;
 template <typename T> class HashSet;
 
+using brave_etld::Matcher;
+
 enum FilterType {
   FTNoFilterType = 0,
   FTRegex = 01,
@@ -84,14 +88,15 @@ enum FilterOption {
 class Filter {
 friend class AdBlockClient;
  public:
+  static bool has_psl_warned;
+
   Filter();
   Filter(const Filter &other);
   Filter(const char * data, int dataLen, char *domainList = nullptr,
-      const char * host = nullptr, int hostLen = -1);
+         const char * host = nullptr, int hostLen = -1);
 
   Filter(FilterType filterType, FilterOption filterOption,
-         FilterOption antiFilterOption,
-         const char * data, int dataLen,
+         FilterOption antiFilterOption, const char * data, int dataLen,
          char *domainList = nullptr, const char * host = nullptr,
          int hostLen = -1);
 
@@ -102,7 +107,7 @@ friend class AdBlockClient;
 
   // Checks to see if any filter matches the input but does not match
   // any exception rule You may want to call the first overload to be
-  // slighly more efficient
+  // slightly more efficient
   bool matches(const char *input, int inputLen,
       FilterOption contextOption = FONoFilterOption,
       const char *contextDomain = nullptr,
@@ -124,12 +129,12 @@ friend class AdBlockClient;
   void parseOptions(const char *input);
 
   // Checks to see if the specified context domain is in the
-  // domain (or antiDmomain) list.
+  // domain (or anti-domain) list.
   bool containsDomain(const char* contextDomain, size_t contextDomainLen,
       bool anti = false) const;
   // Returns true if the filter is composed of only domains and no anti domains
   // Note that the set of all domain and anti-domain rules are not mutually
-  // exclusive.  One xapmle is:
+  // exclusive.  One example is:
   // domain=example.com|~foo.example.com restricts the filter to the example.com
   // domain with the exception of "foo.example.com" subdomain.
   bool isDomainOnlyFilter();
@@ -196,6 +201,11 @@ friend class AdBlockClient;
   HashSet<ContextDomain>* antiDomains;
   bool domainsParsed;
 
+  void setEtldMatcher(Matcher * newMatcher) {
+    etldMatcher = newMatcher;
+  }
+  Matcher * etldMatcher = nullptr;
+
  protected:
   // Fills |domains| and |antiDomains| sets
   void parseDomains(const char *domainList);
@@ -205,9 +215,16 @@ friend class AdBlockClient;
   void parseOption(const char *input, int len);
 };
 
-bool isThirdPartyHost(const char *baseContextHost,
+bool isThirdPartyHost(
+    const char *baseContextHost,
     int baseContextHostLen,
     const char *testHost,
+    int testHostLen,
+    Matcher * matcher = nullptr);
+
+bool isMatchingHostAnchor(const char *ruleHost,
+    int ruleHostLen,
+    const char *testHost,
     int testHostLen);
 
 static inline bool isEndOfLine(char c) {
diff --git a/lib/util.js b/lib/util.js
index 7880fc5..eeeae0c 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -12,10 +12,11 @@ const {AdBlockClient, adBlockLists} = require('..')
  *
  * @param filterRuleData -- either a string, describing adblock filter riles,
  *                          or an array of such strings.
- * @param options        -- an optional object, describing parse options.
- *                          currently the only used rule is "keepRuleText",
- *                          which is a boolean flag determine whether to keep
- *                          the original filter rule text.
+ * @param options  -- an optional object, describing parse options.
+ *                    currently the only used rules are "keepRuleText",
+ *                    which is a boolean flag determine whether to keep
+ *                    the original filter rule text, and "publicSuffixRules",
+ *                    which is a string describing public suffix rules.
  */
 const makeAdBlockClientFromString = (filterRuleData, options) => {
   const keepRuleText = !!(options && options.keepRuleText)
@@ -26,6 +27,11 @@ const makeAdBlockClientFromString = (filterRuleData, options) => {
     } else {
       client.parse(filterRuleData, keepRuleText)
     }
+
+    if (options && options.publicSuffixRules) {
+      client.parsePublicSuffixRules(options.publicSuffixRules)
+    }
+
     resolve(client)
   })
 }
@@ -50,12 +56,14 @@ const makeAdBlockClientFromDATFile = (datFilePath) => {
 
 /**
  * Creates an ABlock client from a list URL
- * @param listURL - The URL to check for obtaining the list.
- * @param filter - A filtering function that can be optionally specified.
- * @param options        -- an optional object, describing parse options.
- *                          currently the only used rule is "keepRuleText",
- *                          which is a boolean flag determine whether to keep
- *                          the original filter rule text.
+ * @param listURL -- The URL to check for obtaining the list.
+ * @param filter  -- A filtering function that can be optionally specified.
+ * @param options -- An optional object, describing parse options.
+ *                   currently the only used rules are "keepRuleText",
+ *                   which is a boolean flag determine whether to keep
+ *                   the original filter rule text, and "publicSuffixRules",
+ *                   which is a string describing public suffix rules.
+ *
  * It will be called with the URL's body and it can filter and return a new string.
  */
 const getSingleListDataFromSingleURL = (listURL, filter, options) => {
@@ -85,10 +93,11 @@ const getSingleListDataFromSingleURL = (listURL, filter, options) => {
  * @param listURL  -- The URL to check for obtaining the list.
  * @param filter   -- A filtering function that can be optionally specified.
  * @param options  -- an optional object, describing parse options.
- *                    currently the only used rule is "keepRuleText",
+ *                    currently the only used rules are "keepRuleText",
  *                    which is a boolean flag determine whether to keep
- *                    the original filter rule text.
-
+ *                    the original filter rule text, and "publicSuffixRules",
+ *                    which is a string describing public suffix rules.
+ *
  * It will be called with the URL's body and it can filter and return a new string.
  */
 const makeAdBlockClientFromListURL = (listURL, filter, options) => {
@@ -135,9 +144,10 @@ const getListFilterFunction = (uuid) => {
  * @param uuid     -- a string, describing on of the UUIDs for a known filter
  *                    list.
  * @param options  -- an optional object, describing parse options.
- *                    currently the only used rule is "keepRuleText",
+ *                    currently the only used rules are "keepRuleText",
  *                    which is a boolean flag determine whether to keep
- *                    the original filter rule text.
+ *                    the original filter rule text, and "publicSuffixRules",
+ *                    which is a string describing public suffix rules.
  */
 const makeAdBlockClientFromListUUID = (uuid, options) => {
   let list = adBlockLists.default.find((l) => l.uuid === uuid)
diff --git a/muon/BUILD.gn b/muon/BUILD.gn
index f74657e..7db8f18 100644
--- a/muon/BUILD.gn
+++ b/muon/BUILD.gn
@@ -44,6 +44,19 @@ source_set("ad_block") {
     "../no_fingerprint_domain.h",
     "../protocol.cc",
     "../protocol.h",
+    "../etld/domain.cc",
+    "../etld/domain.h",
+    "../etld/matcher.cc",
+    "../etld/matcher.h",
+    "../etld/parser.cc",
+    "../etld/parser.h",
+    "../etld/public_suffix_rule.cc",
+    "../etld/public_suffix_rule.h",
+    "../etld/public_suffix_rule_set.cc",
+    "../etld/public_suffix_rule_set.h",
+    "../etld/serialization.cc",
+    "../etld/serialization.h",
+    "../etld/types.h",
   ]
 
   deps = [
diff --git a/scripts/check.js b/scripts/check.js
index 2c768a1..c1c1dcc 100644
--- a/scripts/check.js
+++ b/scripts/check.js
@@ -23,6 +23,8 @@
  * Get stats for a particular adblock list:
  *   node scripts/check.js  --uuid 67F880F5-7602-4042-8A3D-01481FD7437A --stats
 */
+const fsLib = require('fs')
+
 const commander = require('commander')
 const {makeAdBlockClientFromListUUID, makeAdBlockClientFromDATFile, makeAdBlockClientFromListURL, makeAdBlockClientFromString, makeAdBlockClientFromFilePath, readSiteList} = require('../lib/util')
 const {FilterOptions} = require('..')
@@ -42,14 +44,20 @@ commander
   .option('-D, --discover', 'If specified does filter discovery for matched filter')
   .option('-s, --stats', 'If specified outputs parsing stats')
   .option('-C, --cache', 'Optionally cache results and use cached results')
+  .option('-P, --public-suffix-rules-path [file]', 'Optional path to a public suffix rule file for eTLD+1 determination')
   .option('-O, --filter-option [filterOption]', 'Filter option to use', filterStringToFilterOption, FilterOptions.noFilterOption)
   .parse(process.argv)
 
 let p = Promise.reject(new Error('Usage: node check.js --location <location> --host <host> [--uuid <uuid>]'))
 
+const publicSuffixRulesText = commander.publicSuffixRulesPath
+  ? fsLib.readFileSync(commander.publicSuffixRulesPath, "utf8")
+  : false
+
 const ruleDiscovery = commander.discover && !commander.dat
 const parseOptions = {
   keepRuleText: !!ruleDiscovery,
+  publicSuffixRules: publicSuffixRulesText,
 }
 
 if (commander.host && (commander.location || commander.list) || commander.stats) {
diff --git a/test/binding.gyp b/test/binding.gyp
index b13fa78..0a91d49 100644
--- a/test/binding.gyp
+++ b/test/binding.gyp
@@ -11,7 +11,22 @@
       "../test/protocol_test.cc",
       "../test/orig_filters_test.cc",
       "../test/etld_test.cc",
+      "../test/etld_serialization_test.cc",
+      "../test/etld_blocking_test.cc",
       "../test/util.cc",
+      "../etld/domain.cc",
+      "../etld/domain.h",
+      "../etld/matcher.cc",
+      "../etld/matcher.h",
+      "../etld/parser.cc",
+      "../etld/parser.h",
+      "../etld/public_suffix_rule.cc",
+      "../etld/public_suffix_rule.h",
+      "../etld/public_suffix_rule_set.cc",
+      "../etld/public_suffix_rule_set.h",
+      "../etld/serialization.cc",
+      "../etld/serialization.h",
+      "../etld/types.h",
       "../protocol.cc",
       "../protocol.h",
       "../ad_block_client.cc",
@@ -26,10 +41,6 @@
       "../filter_list.h",
       "../no_fingerprint_domain.cc",
       "../no_fingerprint_domain.h",
-      "../etld/domain.cc",
-      "../etld/domain.h",
-      "../etld/public_suffix_rule.cc",
-      "../etld/public_suffix_rule.h",
       "../node_modules/bloom-filter-cpp/BloomFilter.cpp",
       "../node_modules/bloom-filter-cpp/BloomFilter.h",
       "../node_modules/bloom-filter-cpp/hashFn.cpp",
diff --git a/test/data/public_suffix_list.dat b/test/data/public_suffix_list.dat
new file mode 100644
index 0000000..d1325d5
--- /dev/null
+++ b/test/data/public_suffix_list.dat
@@ -0,0 +1,12742 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+// Please pull this list from, and only from https://publicsuffix.org/list/public_suffix_list.dat,
+// rather than any other VCS sites. Pulling from any other URL is not guaranteed to be supported.
+
+// Instructions on pulling and using this list can be found at https://publicsuffix.org/list/.
+
+// ===BEGIN ICANN DOMAINS===
+
+// ac : https://en.wikipedia.org/wiki/.ac
+ac
+com.ac
+edu.ac
+gov.ac
+net.ac
+mil.ac
+org.ac
+
+// ad : https://en.wikipedia.org/wiki/.ad
+ad
+nom.ad
+
+// ae : https://en.wikipedia.org/wiki/.ae
+// see also: "Domain Name Eligibility Policy" at http://www.aeda.ae/eng/aepolicy.php
+ae
+co.ae
+net.ae
+org.ae
+sch.ae
+ac.ae
+gov.ae
+mil.ae
+
+// aero : see https://www.information.aero/index.php?id=66
+aero
+accident-investigation.aero
+accident-prevention.aero
+aerobatic.aero
+aeroclub.aero
+aerodrome.aero
+agents.aero
+aircraft.aero
+airline.aero
+airport.aero
+air-surveillance.aero
+airtraffic.aero
+air-traffic-control.aero
+ambulance.aero
+amusement.aero
+association.aero
+author.aero
+ballooning.aero
+broker.aero
+caa.aero
+cargo.aero
+catering.aero
+certification.aero
+championship.aero
+charter.aero
+civilaviation.aero
+club.aero
+conference.aero
+consultant.aero
+consulting.aero
+control.aero
+council.aero
+crew.aero
+design.aero
+dgca.aero
+educator.aero
+emergency.aero
+engine.aero
+engineer.aero
+entertainment.aero
+equipment.aero
+exchange.aero
+express.aero
+federation.aero
+flight.aero
+freight.aero
+fuel.aero
+gliding.aero
+government.aero
+groundhandling.aero
+group.aero
+hanggliding.aero
+homebuilt.aero
+insurance.aero
+journal.aero
+journalist.aero
+leasing.aero
+logistics.aero
+magazine.aero
+maintenance.aero
+media.aero
+microlight.aero
+modelling.aero
+navigation.aero
+parachuting.aero
+paragliding.aero
+passenger-association.aero
+pilot.aero
+press.aero
+production.aero
+recreation.aero
+repbody.aero
+res.aero
+research.aero
+rotorcraft.aero
+safety.aero
+scientist.aero
+services.aero
+show.aero
+skydiving.aero
+software.aero
+student.aero
+trader.aero
+trading.aero
+trainer.aero
+union.aero
+workinggroup.aero
+works.aero
+
+// af : http://www.nic.af/help.jsp
+af
+gov.af
+com.af
+org.af
+net.af
+edu.af
+
+// ag : http://www.nic.ag/prices.htm
+ag
+com.ag
+org.ag
+net.ag
+co.ag
+nom.ag
+
+// ai : http://nic.com.ai/
+ai
+off.ai
+com.ai
+net.ai
+org.ai
+
+// al : http://www.ert.gov.al/ert_alb/faq_det.html?Id=31
+al
+com.al
+edu.al
+gov.al
+mil.al
+net.al
+org.al
+
+// am : https://en.wikipedia.org/wiki/.am
+am
+
+// ao : https://en.wikipedia.org/wiki/.ao
+// http://www.dns.ao/REGISTR.DOC
+ao
+ed.ao
+gv.ao
+og.ao
+co.ao
+pb.ao
+it.ao
+
+// aq : https://en.wikipedia.org/wiki/.aq
+aq
+
+// ar : https://nic.ar/nic-argentina/normativa-vigente
+ar
+com.ar
+edu.ar
+gob.ar
+gov.ar
+int.ar
+mil.ar
+musica.ar
+net.ar
+org.ar
+tur.ar
+
+// arpa : https://en.wikipedia.org/wiki/.arpa
+// Confirmed by registry <iana-questions@icann.org> 2008-06-18
+arpa
+e164.arpa
+in-addr.arpa
+ip6.arpa
+iris.arpa
+uri.arpa
+urn.arpa
+
+// as : https://en.wikipedia.org/wiki/.as
+as
+gov.as
+
+// asia : https://en.wikipedia.org/wiki/.asia
+asia
+
+// at : https://en.wikipedia.org/wiki/.at
+// Confirmed by registry <it@nic.at> 2008-06-17
+at
+ac.at
+co.at
+gv.at
+or.at
+
+// au : https://en.wikipedia.org/wiki/.au
+// http://www.auda.org.au/
+au
+// 2LDs
+com.au
+net.au
+org.au
+edu.au
+gov.au
+asn.au
+id.au
+// Historic 2LDs (closed to new registration, but sites still exist)
+info.au
+conf.au
+oz.au
+// CGDNs - http://www.cgdn.org.au/
+act.au
+nsw.au
+nt.au
+qld.au
+sa.au
+tas.au
+vic.au
+wa.au
+// 3LDs
+act.edu.au
+nsw.edu.au
+nt.edu.au
+qld.edu.au
+sa.edu.au
+tas.edu.au
+vic.edu.au
+wa.edu.au
+// act.gov.au  Bug 984824 - Removed at request of Greg Tankard
+// nsw.gov.au  Bug 547985 - Removed at request of <Shae.Donelan@services.nsw.gov.au>
+// nt.gov.au  Bug 940478 - Removed at request of Greg Connors <Greg.Connors@nt.gov.au>
+qld.gov.au
+sa.gov.au
+tas.gov.au
+vic.gov.au
+wa.gov.au
+
+// aw : https://en.wikipedia.org/wiki/.aw
+aw
+com.aw
+
+// ax : https://en.wikipedia.org/wiki/.ax
+ax
+
+// az : https://en.wikipedia.org/wiki/.az
+az
+com.az
+net.az
+int.az
+gov.az
+org.az
+edu.az
+info.az
+pp.az
+mil.az
+name.az
+pro.az
+biz.az
+
+// ba : http://nic.ba/users_data/files/pravilnik_o_registraciji.pdf
+ba
+com.ba
+edu.ba
+gov.ba
+mil.ba
+net.ba
+org.ba
+
+// bb : https://en.wikipedia.org/wiki/.bb
+bb
+biz.bb
+co.bb
+com.bb
+edu.bb
+gov.bb
+info.bb
+net.bb
+org.bb
+store.bb
+tv.bb
+
+// bd : https://en.wikipedia.org/wiki/.bd
+*.bd
+
+// be : https://en.wikipedia.org/wiki/.be
+// Confirmed by registry <tech@dns.be> 2008-06-08
+be
+ac.be
+
+// bf : https://en.wikipedia.org/wiki/.bf
+bf
+gov.bf
+
+// bg : https://en.wikipedia.org/wiki/.bg
+// https://www.register.bg/user/static/rules/en/index.html
+bg
+a.bg
+b.bg
+c.bg
+d.bg
+e.bg
+f.bg
+g.bg
+h.bg
+i.bg
+j.bg
+k.bg
+l.bg
+m.bg
+n.bg
+o.bg
+p.bg
+q.bg
+r.bg
+s.bg
+t.bg
+u.bg
+v.bg
+w.bg
+x.bg
+y.bg
+z.bg
+0.bg
+1.bg
+2.bg
+3.bg
+4.bg
+5.bg
+6.bg
+7.bg
+8.bg
+9.bg
+
+// bh : https://en.wikipedia.org/wiki/.bh
+bh
+com.bh
+edu.bh
+net.bh
+org.bh
+gov.bh
+
+// bi : https://en.wikipedia.org/wiki/.bi
+// http://whois.nic.bi/
+bi
+co.bi
+com.bi
+edu.bi
+or.bi
+org.bi
+
+// biz : https://en.wikipedia.org/wiki/.biz
+biz
+
+// bj : https://en.wikipedia.org/wiki/.bj
+bj
+asso.bj
+barreau.bj
+gouv.bj
+
+// bm : http://www.bermudanic.bm/dnr-text.txt
+bm
+com.bm
+edu.bm
+gov.bm
+net.bm
+org.bm
+
+// bn : http://www.bnnic.bn/faqs
+bn
+com.bn
+edu.bn
+gov.bn
+net.bn
+org.bn
+
+// bo : https://nic.bo/delegacion2015.php#h-1.10
+bo
+com.bo
+edu.bo
+gob.bo
+int.bo
+org.bo
+net.bo
+mil.bo
+tv.bo
+web.bo
+// Social Domains
+academia.bo
+agro.bo
+arte.bo
+blog.bo
+bolivia.bo
+ciencia.bo
+cooperativa.bo
+democracia.bo
+deporte.bo
+ecologia.bo
+economia.bo
+empresa.bo
+indigena.bo
+industria.bo
+info.bo
+medicina.bo
+movimiento.bo
+musica.bo
+natural.bo
+nombre.bo
+noticias.bo
+patria.bo
+politica.bo
+profesional.bo
+plurinacional.bo
+pueblo.bo
+revista.bo
+salud.bo
+tecnologia.bo
+tksat.bo
+transporte.bo
+wiki.bo
+
+// br : http://registro.br/dominio/categoria.html
+// Submitted by registry <fneves@registro.br>
+br
+9guacu.br
+abc.br
+adm.br
+adv.br
+agr.br
+aju.br
+am.br
+anani.br
+aparecida.br
+arq.br
+art.br
+ato.br
+b.br
+barueri.br
+belem.br
+bhz.br
+bio.br
+blog.br
+bmd.br
+boavista.br
+bsb.br
+campinagrande.br
+campinas.br
+caxias.br
+cim.br
+cng.br
+cnt.br
+com.br
+contagem.br
+coop.br
+cri.br
+cuiaba.br
+curitiba.br
+def.br
+ecn.br
+eco.br
+edu.br
+emp.br
+eng.br
+esp.br
+etc.br
+eti.br
+far.br
+feira.br
+flog.br
+floripa.br
+fm.br
+fnd.br
+fortal.br
+fot.br
+foz.br
+fst.br
+g12.br
+ggf.br
+goiania.br
+gov.br
+// gov.br 26 states + df https://en.wikipedia.org/wiki/States_of_Brazil
+ac.gov.br
+al.gov.br
+am.gov.br
+ap.gov.br
+ba.gov.br
+ce.gov.br
+df.gov.br
+es.gov.br
+go.gov.br
+ma.gov.br
+mg.gov.br
+ms.gov.br
+mt.gov.br
+pa.gov.br
+pb.gov.br
+pe.gov.br
+pi.gov.br
+pr.gov.br
+rj.gov.br
+rn.gov.br
+ro.gov.br
+rr.gov.br
+rs.gov.br
+sc.gov.br
+se.gov.br
+sp.gov.br
+to.gov.br
+gru.br
+imb.br
+ind.br
+inf.br
+jab.br
+jampa.br
+jdf.br
+joinville.br
+jor.br
+jus.br
+leg.br
+lel.br
+londrina.br
+macapa.br
+maceio.br
+manaus.br
+maringa.br
+mat.br
+med.br
+mil.br
+morena.br
+mp.br
+mus.br
+natal.br
+net.br
+niteroi.br
+*.nom.br
+not.br
+ntr.br
+odo.br
+ong.br
+org.br
+osasco.br
+palmas.br
+poa.br
+ppg.br
+pro.br
+psc.br
+psi.br
+pvh.br
+qsl.br
+radio.br
+rec.br
+recife.br
+ribeirao.br
+rio.br
+riobranco.br
+riopreto.br
+salvador.br
+sampa.br
+santamaria.br
+santoandre.br
+saobernardo.br
+saogonca.br
+sjc.br
+slg.br
+slz.br
+sorocaba.br
+srv.br
+taxi.br
+teo.br
+the.br
+tmp.br
+trd.br
+tur.br
+tv.br
+udi.br
+vet.br
+vix.br
+vlog.br
+wiki.br
+zlg.br
+
+// bs : http://www.nic.bs/rules.html
+bs
+com.bs
+net.bs
+org.bs
+edu.bs
+gov.bs
+
+// bt : https://en.wikipedia.org/wiki/.bt
+bt
+com.bt
+edu.bt
+gov.bt
+net.bt
+org.bt
+
+// bv : No registrations at this time.
+// Submitted by registry <jarle@uninett.no>
+bv
+
+// bw : https://en.wikipedia.org/wiki/.bw
+// http://www.gobin.info/domainname/bw.doc
+// list of other 2nd level tlds ?
+bw
+co.bw
+org.bw
+
+// by : https://en.wikipedia.org/wiki/.by
+// http://tld.by/rules_2006_en.html
+// list of other 2nd level tlds ?
+by
+gov.by
+mil.by
+// Official information does not indicate that com.by is a reserved
+// second-level domain, but it's being used as one (see www.google.com.by and
+// www.yahoo.com.by, for example), so we list it here for safety's sake.
+com.by
+
+// http://hoster.by/
+of.by
+
+// bz : https://en.wikipedia.org/wiki/.bz
+// http://www.belizenic.bz/
+bz
+com.bz
+net.bz
+org.bz
+edu.bz
+gov.bz
+
+// ca : https://en.wikipedia.org/wiki/.ca
+ca
+// ca geographical names
+ab.ca
+bc.ca
+mb.ca
+nb.ca
+nf.ca
+nl.ca
+ns.ca
+nt.ca
+nu.ca
+on.ca
+pe.ca
+qc.ca
+sk.ca
+yk.ca
+// gc.ca: https://en.wikipedia.org/wiki/.gc.ca
+// see also: http://registry.gc.ca/en/SubdomainFAQ
+gc.ca
+
+// cat : https://en.wikipedia.org/wiki/.cat
+cat
+
+// cc : https://en.wikipedia.org/wiki/.cc
+cc
+
+// cd : https://en.wikipedia.org/wiki/.cd
+// see also: https://www.nic.cd/domain/insertDomain_2.jsp?act=1
+cd
+gov.cd
+
+// cf : https://en.wikipedia.org/wiki/.cf
+cf
+
+// cg : https://en.wikipedia.org/wiki/.cg
+cg
+
+// ch : https://en.wikipedia.org/wiki/.ch
+ch
+
+// ci : https://en.wikipedia.org/wiki/.ci
+// http://www.nic.ci/index.php?page=charte
+ci
+org.ci
+or.ci
+com.ci
+co.ci
+edu.ci
+ed.ci
+ac.ci
+net.ci
+go.ci
+asso.ci
+aéroport.ci
+int.ci
+presse.ci
+md.ci
+gouv.ci
+
+// ck : https://en.wikipedia.org/wiki/.ck
+*.ck
+!www.ck
+
+// cl : https://en.wikipedia.org/wiki/.cl
+cl
+gov.cl
+gob.cl
+co.cl
+mil.cl
+
+// cm : https://en.wikipedia.org/wiki/.cm plus bug 981927
+cm
+co.cm
+com.cm
+gov.cm
+net.cm
+
+// cn : https://en.wikipedia.org/wiki/.cn
+// Submitted by registry <tanyaling@cnnic.cn>
+cn
+ac.cn
+com.cn
+edu.cn
+gov.cn
+net.cn
+org.cn
+mil.cn
+公司.cn
+网络.cn
+網絡.cn
+// cn geographic names
+ah.cn
+bj.cn
+cq.cn
+fj.cn
+gd.cn
+gs.cn
+gz.cn
+gx.cn
+ha.cn
+hb.cn
+he.cn
+hi.cn
+hl.cn
+hn.cn
+jl.cn
+js.cn
+jx.cn
+ln.cn
+nm.cn
+nx.cn
+qh.cn
+sc.cn
+sd.cn
+sh.cn
+sn.cn
+sx.cn
+tj.cn
+xj.cn
+xz.cn
+yn.cn
+zj.cn
+hk.cn
+mo.cn
+tw.cn
+
+// co : https://en.wikipedia.org/wiki/.co
+// Submitted by registry <tecnico@uniandes.edu.co>
+co
+arts.co
+com.co
+edu.co
+firm.co
+gov.co
+info.co
+int.co
+mil.co
+net.co
+nom.co
+org.co
+rec.co
+web.co
+
+// com : https://en.wikipedia.org/wiki/.com
+com
+
+// coop : https://en.wikipedia.org/wiki/.coop
+coop
+
+// cr : http://www.nic.cr/niccr_publico/showRegistroDominiosScreen.do
+cr
+ac.cr
+co.cr
+ed.cr
+fi.cr
+go.cr
+or.cr
+sa.cr
+
+// cu : https://en.wikipedia.org/wiki/.cu
+cu
+com.cu
+edu.cu
+org.cu
+net.cu
+gov.cu
+inf.cu
+
+// cv : https://en.wikipedia.org/wiki/.cv
+cv
+
+// cw : http://www.una.cw/cw_registry/
+// Confirmed by registry <registry@una.net> 2013-03-26
+cw
+com.cw
+edu.cw
+net.cw
+org.cw
+
+// cx : https://en.wikipedia.org/wiki/.cx
+// list of other 2nd level tlds ?
+cx
+gov.cx
+
+// cy : http://www.nic.cy/
+// Submitted by registry Panayiotou Fotia <cydns@ucy.ac.cy>
+cy
+ac.cy
+biz.cy
+com.cy
+ekloges.cy
+gov.cy
+ltd.cy
+name.cy
+net.cy
+org.cy
+parliament.cy
+press.cy
+pro.cy
+tm.cy
+
+// cz : https://en.wikipedia.org/wiki/.cz
+cz
+
+// de : https://en.wikipedia.org/wiki/.de
+// Confirmed by registry <ops@denic.de> (with technical
+// reservations) 2008-07-01
+de
+
+// dj : https://en.wikipedia.org/wiki/.dj
+dj
+
+// dk : https://en.wikipedia.org/wiki/.dk
+// Confirmed by registry <robert@dk-hostmaster.dk> 2008-06-17
+dk
+
+// dm : https://en.wikipedia.org/wiki/.dm
+dm
+com.dm
+net.dm
+org.dm
+edu.dm
+gov.dm
+
+// do : https://en.wikipedia.org/wiki/.do
+do
+art.do
+com.do
+edu.do
+gob.do
+gov.do
+mil.do
+net.do
+org.do
+sld.do
+web.do
+
+// dz : https://en.wikipedia.org/wiki/.dz
+dz
+com.dz
+org.dz
+net.dz
+gov.dz
+edu.dz
+asso.dz
+pol.dz
+art.dz
+
+// ec : http://www.nic.ec/reg/paso1.asp
+// Submitted by registry <vabboud@nic.ec>
+ec
+com.ec
+info.ec
+net.ec
+fin.ec
+k12.ec
+med.ec
+pro.ec
+org.ec
+edu.ec
+gov.ec
+gob.ec
+mil.ec
+
+// edu : https://en.wikipedia.org/wiki/.edu
+edu
+
+// ee : http://www.eenet.ee/EENet/dom_reeglid.html#lisa_B
+ee
+edu.ee
+gov.ee
+riik.ee
+lib.ee
+med.ee
+com.ee
+pri.ee
+aip.ee
+org.ee
+fie.ee
+
+// eg : https://en.wikipedia.org/wiki/.eg
+eg
+com.eg
+edu.eg
+eun.eg
+gov.eg
+mil.eg
+name.eg
+net.eg
+org.eg
+sci.eg
+
+// er : https://en.wikipedia.org/wiki/.er
+*.er
+
+// es : https://www.nic.es/site_ingles/ingles/dominios/index.html
+es
+com.es
+nom.es
+org.es
+gob.es
+edu.es
+
+// et : https://en.wikipedia.org/wiki/.et
+et
+com.et
+gov.et
+org.et
+edu.et
+biz.et
+name.et
+info.et
+net.et
+
+// eu : https://en.wikipedia.org/wiki/.eu
+eu
+
+// fi : https://en.wikipedia.org/wiki/.fi
+fi
+// aland.fi : https://en.wikipedia.org/wiki/.ax
+// This domain is being phased out in favor of .ax. As there are still many
+// domains under aland.fi, we still keep it on the list until aland.fi is
+// completely removed.
+// TODO: Check for updates (expected to be phased out around Q1/2009)
+aland.fi
+
+// fj : https://en.wikipedia.org/wiki/.fj
+*.fj
+
+// fk : https://en.wikipedia.org/wiki/.fk
+*.fk
+
+// fm : https://en.wikipedia.org/wiki/.fm
+fm
+
+// fo : https://en.wikipedia.org/wiki/.fo
+fo
+
+// fr : http://www.afnic.fr/
+// domaines descriptifs : http://www.afnic.fr/obtenir/chartes/nommage-fr/annexe-descriptifs
+fr
+com.fr
+asso.fr
+nom.fr
+prd.fr
+presse.fr
+tm.fr
+// domaines sectoriels : http://www.afnic.fr/obtenir/chartes/nommage-fr/annexe-sectoriels
+aeroport.fr
+assedic.fr
+avocat.fr
+avoues.fr
+cci.fr
+chambagri.fr
+chirurgiens-dentistes.fr
+experts-comptables.fr
+geometre-expert.fr
+gouv.fr
+greta.fr
+huissier-justice.fr
+medecin.fr
+notaires.fr
+pharmacien.fr
+port.fr
+veterinaire.fr
+
+// ga : https://en.wikipedia.org/wiki/.ga
+ga
+
+// gb : This registry is effectively dormant
+// Submitted by registry <Damien.Shaw@ja.net>
+gb
+
+// gd : https://en.wikipedia.org/wiki/.gd
+gd
+
+// ge : http://www.nic.net.ge/policy_en.pdf
+ge
+com.ge
+edu.ge
+gov.ge
+org.ge
+mil.ge
+net.ge
+pvt.ge
+
+// gf : https://en.wikipedia.org/wiki/.gf
+gf
+
+// gg : http://www.channelisles.net/register-domains/
+// Confirmed by registry <nigel@channelisles.net> 2013-11-28
+gg
+co.gg
+net.gg
+org.gg
+
+// gh : https://en.wikipedia.org/wiki/.gh
+// see also: http://www.nic.gh/reg_now.php
+// Although domains directly at second level are not possible at the moment,
+// they have been possible for some time and may come back.
+gh
+com.gh
+edu.gh
+gov.gh
+org.gh
+mil.gh
+
+// gi : http://www.nic.gi/rules.html
+gi
+com.gi
+ltd.gi
+gov.gi
+mod.gi
+edu.gi
+org.gi
+
+// gl : https://en.wikipedia.org/wiki/.gl
+// http://nic.gl
+gl
+co.gl
+com.gl
+edu.gl
+net.gl
+org.gl
+
+// gm : http://www.nic.gm/htmlpages%5Cgm-policy.htm
+gm
+
+// gn : http://psg.com/dns/gn/gn.txt
+// Submitted by registry <randy@psg.com>
+gn
+ac.gn
+com.gn
+edu.gn
+gov.gn
+org.gn
+net.gn
+
+// gov : https://en.wikipedia.org/wiki/.gov
+gov
+
+// gp : http://www.nic.gp/index.php?lang=en
+gp
+com.gp
+net.gp
+mobi.gp
+edu.gp
+org.gp
+asso.gp
+
+// gq : https://en.wikipedia.org/wiki/.gq
+gq
+
+// gr : https://grweb.ics.forth.gr/english/1617-B-2005.html
+// Submitted by registry <segred@ics.forth.gr>
+gr
+com.gr
+edu.gr
+net.gr
+org.gr
+gov.gr
+
+// gs : https://en.wikipedia.org/wiki/.gs
+gs
+
+// gt : http://www.gt/politicas_de_registro.html
+gt
+com.gt
+edu.gt
+gob.gt
+ind.gt
+mil.gt
+net.gt
+org.gt
+
+// gu : http://gadao.gov.gu/register.html
+// University of Guam : https://www.uog.edu
+// Submitted by uognoc@triton.uog.edu
+gu
+com.gu
+edu.gu
+gov.gu
+guam.gu
+info.gu
+net.gu
+org.gu
+web.gu
+
+// gw : https://en.wikipedia.org/wiki/.gw
+gw
+
+// gy : https://en.wikipedia.org/wiki/.gy
+// http://registry.gy/
+gy
+co.gy
+com.gy
+edu.gy
+gov.gy
+net.gy
+org.gy
+
+// hk : https://www.hkirc.hk
+// Submitted by registry <hk.tech@hkirc.hk>
+hk
+com.hk
+edu.hk
+gov.hk
+idv.hk
+net.hk
+org.hk
+公司.hk
+教育.hk
+敎育.hk
+政府.hk
+個人.hk
+个人.hk
+箇人.hk
+網络.hk
+网络.hk
+组織.hk
+網絡.hk
+网絡.hk
+组织.hk
+組織.hk
+組织.hk
+
+// hm : https://en.wikipedia.org/wiki/.hm
+hm
+
+// hn : http://www.nic.hn/politicas/ps02,,05.html
+hn
+com.hn
+edu.hn
+org.hn
+net.hn
+mil.hn
+gob.hn
+
+// hr : http://www.dns.hr/documents/pdf/HRTLD-regulations.pdf
+hr
+iz.hr
+from.hr
+name.hr
+com.hr
+
+// ht : http://www.nic.ht/info/charte.cfm
+ht
+com.ht
+shop.ht
+firm.ht
+info.ht
+adult.ht
+net.ht
+pro.ht
+org.ht
+med.ht
+art.ht
+coop.ht
+pol.ht
+asso.ht
+edu.ht
+rel.ht
+gouv.ht
+perso.ht
+
+// hu : http://www.domain.hu/domain/English/sld.html
+// Confirmed by registry <pasztor@iszt.hu> 2008-06-12
+hu
+co.hu
+info.hu
+org.hu
+priv.hu
+sport.hu
+tm.hu
+2000.hu
+agrar.hu
+bolt.hu
+casino.hu
+city.hu
+erotica.hu
+erotika.hu
+film.hu
+forum.hu
+games.hu
+hotel.hu
+ingatlan.hu
+jogasz.hu
+konyvelo.hu
+lakas.hu
+media.hu
+news.hu
+reklam.hu
+sex.hu
+shop.hu
+suli.hu
+szex.hu
+tozsde.hu
+utazas.hu
+video.hu
+
+// id : https://pandi.id/en/domain/registration-requirements/
+id
+ac.id
+biz.id
+co.id
+desa.id
+go.id
+mil.id
+my.id
+net.id
+or.id
+ponpes.id
+sch.id
+web.id
+
+// ie : https://en.wikipedia.org/wiki/.ie
+ie
+gov.ie
+
+// il : http://www.isoc.org.il/domains/
+il
+ac.il
+co.il
+gov.il
+idf.il
+k12.il
+muni.il
+net.il
+org.il
+
+// im : https://www.nic.im/
+// Submitted by registry <info@nic.im>
+im
+ac.im
+co.im
+com.im
+ltd.co.im
+net.im
+org.im
+plc.co.im
+tt.im
+tv.im
+
+// in : https://en.wikipedia.org/wiki/.in
+// see also: https://registry.in/Policies
+// Please note, that nic.in is not an official eTLD, but used by most
+// government institutions.
+in
+co.in
+firm.in
+net.in
+org.in
+gen.in
+ind.in
+nic.in
+ac.in
+edu.in
+res.in
+gov.in
+mil.in
+
+// info : https://en.wikipedia.org/wiki/.info
+info
+
+// int : https://en.wikipedia.org/wiki/.int
+// Confirmed by registry <iana-questions@icann.org> 2008-06-18
+int
+eu.int
+
+// io : http://www.nic.io/rules.html
+// list of other 2nd level tlds ?
+io
+com.io
+
+// iq : http://www.cmc.iq/english/iq/iqregister1.htm
+iq
+gov.iq
+edu.iq
+mil.iq
+com.iq
+org.iq
+net.iq
+
+// ir : http://www.nic.ir/Terms_and_Conditions_ir,_Appendix_1_Domain_Rules
+// Also see http://www.nic.ir/Internationalized_Domain_Names
+// Two <iran>.ir entries added at request of <tech-team@nic.ir>, 2010-04-16
+ir
+ac.ir
+co.ir
+gov.ir
+id.ir
+net.ir
+org.ir
+sch.ir
+// xn--mgba3a4f16a.ir (<iran>.ir, Persian YEH)
+ایران.ir
+// xn--mgba3a4fra.ir (<iran>.ir, Arabic YEH)
+ايران.ir
+
+// is : http://www.isnic.is/domain/rules.php
+// Confirmed by registry <marius@isgate.is> 2008-12-06
+is
+net.is
+com.is
+edu.is
+gov.is
+org.is
+int.is
+
+// it : https://en.wikipedia.org/wiki/.it
+it
+gov.it
+edu.it
+// Reserved geo-names (regions and provinces):
+// http://www.nic.it/sites/default/files/docs/Regulation_assignation_v7.1.pdf
+// Regions
+abr.it
+abruzzo.it
+aosta-valley.it
+aostavalley.it
+bas.it
+basilicata.it
+cal.it
+calabria.it
+cam.it
+campania.it
+emilia-romagna.it
+emiliaromagna.it
+emr.it
+friuli-v-giulia.it
+friuli-ve-giulia.it
+friuli-vegiulia.it
+friuli-venezia-giulia.it
+friuli-veneziagiulia.it
+friuli-vgiulia.it
+friuliv-giulia.it
+friulive-giulia.it
+friulivegiulia.it
+friulivenezia-giulia.it
+friuliveneziagiulia.it
+friulivgiulia.it
+fvg.it
+laz.it
+lazio.it
+lig.it
+liguria.it
+lom.it
+lombardia.it
+lombardy.it
+lucania.it
+mar.it
+marche.it
+mol.it
+molise.it
+piedmont.it
+piemonte.it
+pmn.it
+pug.it
+puglia.it
+sar.it
+sardegna.it
+sardinia.it
+sic.it
+sicilia.it
+sicily.it
+taa.it
+tos.it
+toscana.it
+trentin-sud-tirol.it
+trentin-süd-tirol.it
+trentin-sudtirol.it
+trentin-südtirol.it
+trentin-sued-tirol.it
+trentin-suedtirol.it
+trentino-a-adige.it
+trentino-aadige.it
+trentino-alto-adige.it
+trentino-altoadige.it
+trentino-s-tirol.it
+trentino-stirol.it
+trentino-sud-tirol.it
+trentino-süd-tirol.it
+trentino-sudtirol.it
+trentino-südtirol.it
+trentino-sued-tirol.it
+trentino-suedtirol.it
+trentino.it
+trentinoa-adige.it
+trentinoaadige.it
+trentinoalto-adige.it
+trentinoaltoadige.it
+trentinos-tirol.it
+trentinostirol.it
+trentinosud-tirol.it
+trentinosüd-tirol.it
+trentinosudtirol.it
+trentinosüdtirol.it
+trentinosued-tirol.it
+trentinosuedtirol.it
+trentinsud-tirol.it
+trentinsüd-tirol.it
+trentinsudtirol.it
+trentinsüdtirol.it
+trentinsued-tirol.it
+trentinsuedtirol.it
+tuscany.it
+umb.it
+umbria.it
+val-d-aosta.it
+val-daosta.it
+vald-aosta.it
+valdaosta.it
+valle-aosta.it
+valle-d-aosta.it
+valle-daosta.it
+valleaosta.it
+valled-aosta.it
+valledaosta.it
+vallee-aoste.it
+vallée-aoste.it
+vallee-d-aoste.it
+vallée-d-aoste.it
+valleeaoste.it
+valléeaoste.it
+valleedaoste.it
+valléedaoste.it
+vao.it
+vda.it
+ven.it
+veneto.it
+// Provinces
+ag.it
+agrigento.it
+al.it
+alessandria.it
+alto-adige.it
+altoadige.it
+an.it
+ancona.it
+andria-barletta-trani.it
+andria-trani-barletta.it
+andriabarlettatrani.it
+andriatranibarletta.it
+ao.it
+aosta.it
+aoste.it
+ap.it
+aq.it
+aquila.it
+ar.it
+arezzo.it
+ascoli-piceno.it
+ascolipiceno.it
+asti.it
+at.it
+av.it
+avellino.it
+ba.it
+balsan-sudtirol.it
+balsan-südtirol.it
+balsan-suedtirol.it
+balsan.it
+bari.it
+barletta-trani-andria.it
+barlettatraniandria.it
+belluno.it
+benevento.it
+bergamo.it
+bg.it
+bi.it
+biella.it
+bl.it
+bn.it
+bo.it
+bologna.it
+bolzano-altoadige.it
+bolzano.it
+bozen-sudtirol.it
+bozen-südtirol.it
+bozen-suedtirol.it
+bozen.it
+br.it
+brescia.it
+brindisi.it
+bs.it
+bt.it
+bulsan-sudtirol.it
+bulsan-südtirol.it
+bulsan-suedtirol.it
+bulsan.it
+bz.it
+ca.it
+cagliari.it
+caltanissetta.it
+campidano-medio.it
+campidanomedio.it
+campobasso.it
+carbonia-iglesias.it
+carboniaiglesias.it
+carrara-massa.it
+carraramassa.it
+caserta.it
+catania.it
+catanzaro.it
+cb.it
+ce.it
+cesena-forli.it
+cesena-forlì.it
+cesenaforli.it
+cesenaforlì.it
+ch.it
+chieti.it
+ci.it
+cl.it
+cn.it
+co.it
+como.it
+cosenza.it
+cr.it
+cremona.it
+crotone.it
+cs.it
+ct.it
+cuneo.it
+cz.it
+dell-ogliastra.it
+dellogliastra.it
+en.it
+enna.it
+fc.it
+fe.it
+fermo.it
+ferrara.it
+fg.it
+fi.it
+firenze.it
+florence.it
+fm.it
+foggia.it
+forli-cesena.it
+forlì-cesena.it
+forlicesena.it
+forlìcesena.it
+fr.it
+frosinone.it
+ge.it
+genoa.it
+genova.it
+go.it
+gorizia.it
+gr.it
+grosseto.it
+iglesias-carbonia.it
+iglesiascarbonia.it
+im.it
+imperia.it
+is.it
+isernia.it
+kr.it
+la-spezia.it
+laquila.it
+laspezia.it
+latina.it
+lc.it
+le.it
+lecce.it
+lecco.it
+li.it
+livorno.it
+lo.it
+lodi.it
+lt.it
+lu.it
+lucca.it
+macerata.it
+mantova.it
+massa-carrara.it
+massacarrara.it
+matera.it
+mb.it
+mc.it
+me.it
+medio-campidano.it
+mediocampidano.it
+messina.it
+mi.it
+milan.it
+milano.it
+mn.it
+mo.it
+modena.it
+monza-brianza.it
+monza-e-della-brianza.it
+monza.it
+monzabrianza.it
+monzaebrianza.it
+monzaedellabrianza.it
+ms.it
+mt.it
+na.it
+naples.it
+napoli.it
+no.it
+novara.it
+nu.it
+nuoro.it
+og.it
+ogliastra.it
+olbia-tempio.it
+olbiatempio.it
+or.it
+oristano.it
+ot.it
+pa.it
+padova.it
+padua.it
+palermo.it
+parma.it
+pavia.it
+pc.it
+pd.it
+pe.it
+perugia.it
+pesaro-urbino.it
+pesarourbino.it
+pescara.it
+pg.it
+pi.it
+piacenza.it
+pisa.it
+pistoia.it
+pn.it
+po.it
+pordenone.it
+potenza.it
+pr.it
+prato.it
+pt.it
+pu.it
+pv.it
+pz.it
+ra.it
+ragusa.it
+ravenna.it
+rc.it
+re.it
+reggio-calabria.it
+reggio-emilia.it
+reggiocalabria.it
+reggioemilia.it
+rg.it
+ri.it
+rieti.it
+rimini.it
+rm.it
+rn.it
+ro.it
+roma.it
+rome.it
+rovigo.it
+sa.it
+salerno.it
+sassari.it
+savona.it
+si.it
+siena.it
+siracusa.it
+so.it
+sondrio.it
+sp.it
+sr.it
+ss.it
+suedtirol.it
+südtirol.it
+sv.it
+ta.it
+taranto.it
+te.it
+tempio-olbia.it
+tempioolbia.it
+teramo.it
+terni.it
+tn.it
+to.it
+torino.it
+tp.it
+tr.it
+trani-andria-barletta.it
+trani-barletta-andria.it
+traniandriabarletta.it
+tranibarlettaandria.it
+trapani.it
+trento.it
+treviso.it
+trieste.it
+ts.it
+turin.it
+tv.it
+ud.it
+udine.it
+urbino-pesaro.it
+urbinopesaro.it
+va.it
+varese.it
+vb.it
+vc.it
+ve.it
+venezia.it
+venice.it
+verbania.it
+vercelli.it
+verona.it
+vi.it
+vibo-valentia.it
+vibovalentia.it
+vicenza.it
+viterbo.it
+vr.it
+vs.it
+vt.it
+vv.it
+
+// je : http://www.channelisles.net/register-domains/
+// Confirmed by registry <nigel@channelisles.net> 2013-11-28
+je
+co.je
+net.je
+org.je
+
+// jm : http://www.com.jm/register.html
+*.jm
+
+// jo : http://www.dns.jo/Registration_policy.aspx
+jo
+com.jo
+org.jo
+net.jo
+edu.jo
+sch.jo
+gov.jo
+mil.jo
+name.jo
+
+// jobs : https://en.wikipedia.org/wiki/.jobs
+jobs
+
+// jp : https://en.wikipedia.org/wiki/.jp
+// http://jprs.co.jp/en/jpdomain.html
+// Submitted by registry <info@jprs.jp>
+jp
+// jp organizational type names
+ac.jp
+ad.jp
+co.jp
+ed.jp
+go.jp
+gr.jp
+lg.jp
+ne.jp
+or.jp
+// jp prefecture type names
+aichi.jp
+akita.jp
+aomori.jp
+chiba.jp
+ehime.jp
+fukui.jp
+fukuoka.jp
+fukushima.jp
+gifu.jp
+gunma.jp
+hiroshima.jp
+hokkaido.jp
+hyogo.jp
+ibaraki.jp
+ishikawa.jp
+iwate.jp
+kagawa.jp
+kagoshima.jp
+kanagawa.jp
+kochi.jp
+kumamoto.jp
+kyoto.jp
+mie.jp
+miyagi.jp
+miyazaki.jp
+nagano.jp
+nagasaki.jp
+nara.jp
+niigata.jp
+oita.jp
+okayama.jp
+okinawa.jp
+osaka.jp
+saga.jp
+saitama.jp
+shiga.jp
+shimane.jp
+shizuoka.jp
+tochigi.jp
+tokushima.jp
+tokyo.jp
+tottori.jp
+toyama.jp
+wakayama.jp
+yamagata.jp
+yamaguchi.jp
+yamanashi.jp
+栃木.jp
+愛知.jp
+愛媛.jp
+兵庫.jp
+熊本.jp
+茨城.jp
+北海道.jp
+千葉.jp
+和歌山.jp
+長崎.jp
+長野.jp
+新潟.jp
+青森.jp
+静岡.jp
+東京.jp
+石川.jp
+埼玉.jp
+三重.jp
+京都.jp
+佐賀.jp
+大分.jp
+大阪.jp
+奈良.jp
+宮城.jp
+宮崎.jp
+富山.jp
+山口.jp
+山形.jp
+山梨.jp
+岩手.jp
+岐阜.jp
+岡山.jp
+島根.jp
+広島.jp
+徳島.jp
+沖縄.jp
+滋賀.jp
+神奈川.jp
+福井.jp
+福岡.jp
+福島.jp
+秋田.jp
+群馬.jp
+香川.jp
+高知.jp
+鳥取.jp
+鹿児島.jp
+// jp geographic type names
+// http://jprs.jp/doc/rule/saisoku-1.html
+*.kawasaki.jp
+*.kitakyushu.jp
+*.kobe.jp
+*.nagoya.jp
+*.sapporo.jp
+*.sendai.jp
+*.yokohama.jp
+!city.kawasaki.jp
+!city.kitakyushu.jp
+!city.kobe.jp
+!city.nagoya.jp
+!city.sapporo.jp
+!city.sendai.jp
+!city.yokohama.jp
+// 4th level registration
+aisai.aichi.jp
+ama.aichi.jp
+anjo.aichi.jp
+asuke.aichi.jp
+chiryu.aichi.jp
+chita.aichi.jp
+fuso.aichi.jp
+gamagori.aichi.jp
+handa.aichi.jp
+hazu.aichi.jp
+hekinan.aichi.jp
+higashiura.aichi.jp
+ichinomiya.aichi.jp
+inazawa.aichi.jp
+inuyama.aichi.jp
+isshiki.aichi.jp
+iwakura.aichi.jp
+kanie.aichi.jp
+kariya.aichi.jp
+kasugai.aichi.jp
+kira.aichi.jp
+kiyosu.aichi.jp
+komaki.aichi.jp
+konan.aichi.jp
+kota.aichi.jp
+mihama.aichi.jp
+miyoshi.aichi.jp
+nishio.aichi.jp
+nisshin.aichi.jp
+obu.aichi.jp
+oguchi.aichi.jp
+oharu.aichi.jp
+okazaki.aichi.jp
+owariasahi.aichi.jp
+seto.aichi.jp
+shikatsu.aichi.jp
+shinshiro.aichi.jp
+shitara.aichi.jp
+tahara.aichi.jp
+takahama.aichi.jp
+tobishima.aichi.jp
+toei.aichi.jp
+togo.aichi.jp
+tokai.aichi.jp
+tokoname.aichi.jp
+toyoake.aichi.jp
+toyohashi.aichi.jp
+toyokawa.aichi.jp
+toyone.aichi.jp
+toyota.aichi.jp
+tsushima.aichi.jp
+yatomi.aichi.jp
+akita.akita.jp
+daisen.akita.jp
+fujisato.akita.jp
+gojome.akita.jp
+hachirogata.akita.jp
+happou.akita.jp
+higashinaruse.akita.jp
+honjo.akita.jp
+honjyo.akita.jp
+ikawa.akita.jp
+kamikoani.akita.jp
+kamioka.akita.jp
+katagami.akita.jp
+kazuno.akita.jp
+kitaakita.akita.jp
+kosaka.akita.jp
+kyowa.akita.jp
+misato.akita.jp
+mitane.akita.jp
+moriyoshi.akita.jp
+nikaho.akita.jp
+noshiro.akita.jp
+odate.akita.jp
+oga.akita.jp
+ogata.akita.jp
+semboku.akita.jp
+yokote.akita.jp
+yurihonjo.akita.jp
+aomori.aomori.jp
+gonohe.aomori.jp
+hachinohe.aomori.jp
+hashikami.aomori.jp
+hiranai.aomori.jp
+hirosaki.aomori.jp
+itayanagi.aomori.jp
+kuroishi.aomori.jp
+misawa.aomori.jp
+mutsu.aomori.jp
+nakadomari.aomori.jp
+noheji.aomori.jp
+oirase.aomori.jp
+owani.aomori.jp
+rokunohe.aomori.jp
+sannohe.aomori.jp
+shichinohe.aomori.jp
+shingo.aomori.jp
+takko.aomori.jp
+towada.aomori.jp
+tsugaru.aomori.jp
+tsuruta.aomori.jp
+abiko.chiba.jp
+asahi.chiba.jp
+chonan.chiba.jp
+chosei.chiba.jp
+choshi.chiba.jp
+chuo.chiba.jp
+funabashi.chiba.jp
+futtsu.chiba.jp
+hanamigawa.chiba.jp
+ichihara.chiba.jp
+ichikawa.chiba.jp
+ichinomiya.chiba.jp
+inzai.chiba.jp
+isumi.chiba.jp
+kamagaya.chiba.jp
+kamogawa.chiba.jp
+kashiwa.chiba.jp
+katori.chiba.jp
+katsuura.chiba.jp
+kimitsu.chiba.jp
+kisarazu.chiba.jp
+kozaki.chiba.jp
+kujukuri.chiba.jp
+kyonan.chiba.jp
+matsudo.chiba.jp
+midori.chiba.jp
+mihama.chiba.jp
+minamiboso.chiba.jp
+mobara.chiba.jp
+mutsuzawa.chiba.jp
+nagara.chiba.jp
+nagareyama.chiba.jp
+narashino.chiba.jp
+narita.chiba.jp
+noda.chiba.jp
+oamishirasato.chiba.jp
+omigawa.chiba.jp
+onjuku.chiba.jp
+otaki.chiba.jp
+sakae.chiba.jp
+sakura.chiba.jp
+shimofusa.chiba.jp
+shirako.chiba.jp
+shiroi.chiba.jp
+shisui.chiba.jp
+sodegaura.chiba.jp
+sosa.chiba.jp
+tako.chiba.jp
+tateyama.chiba.jp
+togane.chiba.jp
+tohnosho.chiba.jp
+tomisato.chiba.jp
+urayasu.chiba.jp
+yachimata.chiba.jp
+yachiyo.chiba.jp
+yokaichiba.chiba.jp
+yokoshibahikari.chiba.jp
+yotsukaido.chiba.jp
+ainan.ehime.jp
+honai.ehime.jp
+ikata.ehime.jp
+imabari.ehime.jp
+iyo.ehime.jp
+kamijima.ehime.jp
+kihoku.ehime.jp
+kumakogen.ehime.jp
+masaki.ehime.jp
+matsuno.ehime.jp
+matsuyama.ehime.jp
+namikata.ehime.jp
+niihama.ehime.jp
+ozu.ehime.jp
+saijo.ehime.jp
+seiyo.ehime.jp
+shikokuchuo.ehime.jp
+tobe.ehime.jp
+toon.ehime.jp
+uchiko.ehime.jp
+uwajima.ehime.jp
+yawatahama.ehime.jp
+echizen.fukui.jp
+eiheiji.fukui.jp
+fukui.fukui.jp
+ikeda.fukui.jp
+katsuyama.fukui.jp
+mihama.fukui.jp
+minamiechizen.fukui.jp
+obama.fukui.jp
+ohi.fukui.jp
+ono.fukui.jp
+sabae.fukui.jp
+sakai.fukui.jp
+takahama.fukui.jp
+tsuruga.fukui.jp
+wakasa.fukui.jp
+ashiya.fukuoka.jp
+buzen.fukuoka.jp
+chikugo.fukuoka.jp
+chikuho.fukuoka.jp
+chikujo.fukuoka.jp
+chikushino.fukuoka.jp
+chikuzen.fukuoka.jp
+chuo.fukuoka.jp
+dazaifu.fukuoka.jp
+fukuchi.fukuoka.jp
+hakata.fukuoka.jp
+higashi.fukuoka.jp
+hirokawa.fukuoka.jp
+hisayama.fukuoka.jp
+iizuka.fukuoka.jp
+inatsuki.fukuoka.jp
+kaho.fukuoka.jp
+kasuga.fukuoka.jp
+kasuya.fukuoka.jp
+kawara.fukuoka.jp
+keisen.fukuoka.jp
+koga.fukuoka.jp
+kurate.fukuoka.jp
+kurogi.fukuoka.jp
+kurume.fukuoka.jp
+minami.fukuoka.jp
+miyako.fukuoka.jp
+miyama.fukuoka.jp
+miyawaka.fukuoka.jp
+mizumaki.fukuoka.jp
+munakata.fukuoka.jp
+nakagawa.fukuoka.jp
+nakama.fukuoka.jp
+nishi.fukuoka.jp
+nogata.fukuoka.jp
+ogori.fukuoka.jp
+okagaki.fukuoka.jp
+okawa.fukuoka.jp
+oki.fukuoka.jp
+omuta.fukuoka.jp
+onga.fukuoka.jp
+onojo.fukuoka.jp
+oto.fukuoka.jp
+saigawa.fukuoka.jp
+sasaguri.fukuoka.jp
+shingu.fukuoka.jp
+shinyoshitomi.fukuoka.jp
+shonai.fukuoka.jp
+soeda.fukuoka.jp
+sue.fukuoka.jp
+tachiarai.fukuoka.jp
+tagawa.fukuoka.jp
+takata.fukuoka.jp
+toho.fukuoka.jp
+toyotsu.fukuoka.jp
+tsuiki.fukuoka.jp
+ukiha.fukuoka.jp
+umi.fukuoka.jp
+usui.fukuoka.jp
+yamada.fukuoka.jp
+yame.fukuoka.jp
+yanagawa.fukuoka.jp
+yukuhashi.fukuoka.jp
+aizubange.fukushima.jp
+aizumisato.fukushima.jp
+aizuwakamatsu.fukushima.jp
+asakawa.fukushima.jp
+bandai.fukushima.jp
+date.fukushima.jp
+fukushima.fukushima.jp
+furudono.fukushima.jp
+futaba.fukushima.jp
+hanawa.fukushima.jp
+higashi.fukushima.jp
+hirata.fukushima.jp
+hirono.fukushima.jp
+iitate.fukushima.jp
+inawashiro.fukushima.jp
+ishikawa.fukushima.jp
+iwaki.fukushima.jp
+izumizaki.fukushima.jp
+kagamiishi.fukushima.jp
+kaneyama.fukushima.jp
+kawamata.fukushima.jp
+kitakata.fukushima.jp
+kitashiobara.fukushima.jp
+koori.fukushima.jp
+koriyama.fukushima.jp
+kunimi.fukushima.jp
+miharu.fukushima.jp
+mishima.fukushima.jp
+namie.fukushima.jp
+nango.fukushima.jp
+nishiaizu.fukushima.jp
+nishigo.fukushima.jp
+okuma.fukushima.jp
+omotego.fukushima.jp
+ono.fukushima.jp
+otama.fukushima.jp
+samegawa.fukushima.jp
+shimogo.fukushima.jp
+shirakawa.fukushima.jp
+showa.fukushima.jp
+soma.fukushima.jp
+sukagawa.fukushima.jp
+taishin.fukushima.jp
+tamakawa.fukushima.jp
+tanagura.fukushima.jp
+tenei.fukushima.jp
+yabuki.fukushima.jp
+yamato.fukushima.jp
+yamatsuri.fukushima.jp
+yanaizu.fukushima.jp
+yugawa.fukushima.jp
+anpachi.gifu.jp
+ena.gifu.jp
+gifu.gifu.jp
+ginan.gifu.jp
+godo.gifu.jp
+gujo.gifu.jp
+hashima.gifu.jp
+hichiso.gifu.jp
+hida.gifu.jp
+higashishirakawa.gifu.jp
+ibigawa.gifu.jp
+ikeda.gifu.jp
+kakamigahara.gifu.jp
+kani.gifu.jp
+kasahara.gifu.jp
+kasamatsu.gifu.jp
+kawaue.gifu.jp
+kitagata.gifu.jp
+mino.gifu.jp
+minokamo.gifu.jp
+mitake.gifu.jp
+mizunami.gifu.jp
+motosu.gifu.jp
+nakatsugawa.gifu.jp
+ogaki.gifu.jp
+sakahogi.gifu.jp
+seki.gifu.jp
+sekigahara.gifu.jp
+shirakawa.gifu.jp
+tajimi.gifu.jp
+takayama.gifu.jp
+tarui.gifu.jp
+toki.gifu.jp
+tomika.gifu.jp
+wanouchi.gifu.jp
+yamagata.gifu.jp
+yaotsu.gifu.jp
+yoro.gifu.jp
+annaka.gunma.jp
+chiyoda.gunma.jp
+fujioka.gunma.jp
+higashiagatsuma.gunma.jp
+isesaki.gunma.jp
+itakura.gunma.jp
+kanna.gunma.jp
+kanra.gunma.jp
+katashina.gunma.jp
+kawaba.gunma.jp
+kiryu.gunma.jp
+kusatsu.gunma.jp
+maebashi.gunma.jp
+meiwa.gunma.jp
+midori.gunma.jp
+minakami.gunma.jp
+naganohara.gunma.jp
+nakanojo.gunma.jp
+nanmoku.gunma.jp
+numata.gunma.jp
+oizumi.gunma.jp
+ora.gunma.jp
+ota.gunma.jp
+shibukawa.gunma.jp
+shimonita.gunma.jp
+shinto.gunma.jp
+showa.gunma.jp
+takasaki.gunma.jp
+takayama.gunma.jp
+tamamura.gunma.jp
+tatebayashi.gunma.jp
+tomioka.gunma.jp
+tsukiyono.gunma.jp
+tsumagoi.gunma.jp
+ueno.gunma.jp
+yoshioka.gunma.jp
+asaminami.hiroshima.jp
+daiwa.hiroshima.jp
+etajima.hiroshima.jp
+fuchu.hiroshima.jp
+fukuyama.hiroshima.jp
+hatsukaichi.hiroshima.jp
+higashihiroshima.hiroshima.jp
+hongo.hiroshima.jp
+jinsekikogen.hiroshima.jp
+kaita.hiroshima.jp
+kui.hiroshima.jp
+kumano.hiroshima.jp
+kure.hiroshima.jp
+mihara.hiroshima.jp
+miyoshi.hiroshima.jp
+naka.hiroshima.jp
+onomichi.hiroshima.jp
+osakikamijima.hiroshima.jp
+otake.hiroshima.jp
+saka.hiroshima.jp
+sera.hiroshima.jp
+seranishi.hiroshima.jp
+shinichi.hiroshima.jp
+shobara.hiroshima.jp
+takehara.hiroshima.jp
+abashiri.hokkaido.jp
+abira.hokkaido.jp
+aibetsu.hokkaido.jp
+akabira.hokkaido.jp
+akkeshi.hokkaido.jp
+asahikawa.hokkaido.jp
+ashibetsu.hokkaido.jp
+ashoro.hokkaido.jp
+assabu.hokkaido.jp
+atsuma.hokkaido.jp
+bibai.hokkaido.jp
+biei.hokkaido.jp
+bifuka.hokkaido.jp
+bihoro.hokkaido.jp
+biratori.hokkaido.jp
+chippubetsu.hokkaido.jp
+chitose.hokkaido.jp
+date.hokkaido.jp
+ebetsu.hokkaido.jp
+embetsu.hokkaido.jp
+eniwa.hokkaido.jp
+erimo.hokkaido.jp
+esan.hokkaido.jp
+esashi.hokkaido.jp
+fukagawa.hokkaido.jp
+fukushima.hokkaido.jp
+furano.hokkaido.jp
+furubira.hokkaido.jp
+haboro.hokkaido.jp
+hakodate.hokkaido.jp
+hamatonbetsu.hokkaido.jp
+hidaka.hokkaido.jp
+higashikagura.hokkaido.jp
+higashikawa.hokkaido.jp
+hiroo.hokkaido.jp
+hokuryu.hokkaido.jp
+hokuto.hokkaido.jp
+honbetsu.hokkaido.jp
+horokanai.hokkaido.jp
+horonobe.hokkaido.jp
+ikeda.hokkaido.jp
+imakane.hokkaido.jp
+ishikari.hokkaido.jp
+iwamizawa.hokkaido.jp
+iwanai.hokkaido.jp
+kamifurano.hokkaido.jp
+kamikawa.hokkaido.jp
+kamishihoro.hokkaido.jp
+kamisunagawa.hokkaido.jp
+kamoenai.hokkaido.jp
+kayabe.hokkaido.jp
+kembuchi.hokkaido.jp
+kikonai.hokkaido.jp
+kimobetsu.hokkaido.jp
+kitahiroshima.hokkaido.jp
+kitami.hokkaido.jp
+kiyosato.hokkaido.jp
+koshimizu.hokkaido.jp
+kunneppu.hokkaido.jp
+kuriyama.hokkaido.jp
+kuromatsunai.hokkaido.jp
+kushiro.hokkaido.jp
+kutchan.hokkaido.jp
+kyowa.hokkaido.jp
+mashike.hokkaido.jp
+matsumae.hokkaido.jp
+mikasa.hokkaido.jp
+minamifurano.hokkaido.jp
+mombetsu.hokkaido.jp
+moseushi.hokkaido.jp
+mukawa.hokkaido.jp
+muroran.hokkaido.jp
+naie.hokkaido.jp
+nakagawa.hokkaido.jp
+nakasatsunai.hokkaido.jp
+nakatombetsu.hokkaido.jp
+nanae.hokkaido.jp
+nanporo.hokkaido.jp
+nayoro.hokkaido.jp
+nemuro.hokkaido.jp
+niikappu.hokkaido.jp
+niki.hokkaido.jp
+nishiokoppe.hokkaido.jp
+noboribetsu.hokkaido.jp
+numata.hokkaido.jp
+obihiro.hokkaido.jp
+obira.hokkaido.jp
+oketo.hokkaido.jp
+okoppe.hokkaido.jp
+otaru.hokkaido.jp
+otobe.hokkaido.jp
+otofuke.hokkaido.jp
+otoineppu.hokkaido.jp
+oumu.hokkaido.jp
+ozora.hokkaido.jp
+pippu.hokkaido.jp
+rankoshi.hokkaido.jp
+rebun.hokkaido.jp
+rikubetsu.hokkaido.jp
+rishiri.hokkaido.jp
+rishirifuji.hokkaido.jp
+saroma.hokkaido.jp
+sarufutsu.hokkaido.jp
+shakotan.hokkaido.jp
+shari.hokkaido.jp
+shibecha.hokkaido.jp
+shibetsu.hokkaido.jp
+shikabe.hokkaido.jp
+shikaoi.hokkaido.jp
+shimamaki.hokkaido.jp
+shimizu.hokkaido.jp
+shimokawa.hokkaido.jp
+shinshinotsu.hokkaido.jp
+shintoku.hokkaido.jp
+shiranuka.hokkaido.jp
+shiraoi.hokkaido.jp
+shiriuchi.hokkaido.jp
+sobetsu.hokkaido.jp
+sunagawa.hokkaido.jp
+taiki.hokkaido.jp
+takasu.hokkaido.jp
+takikawa.hokkaido.jp
+takinoue.hokkaido.jp
+teshikaga.hokkaido.jp
+tobetsu.hokkaido.jp
+tohma.hokkaido.jp
+tomakomai.hokkaido.jp
+tomari.hokkaido.jp
+toya.hokkaido.jp
+toyako.hokkaido.jp
+toyotomi.hokkaido.jp
+toyoura.hokkaido.jp
+tsubetsu.hokkaido.jp
+tsukigata.hokkaido.jp
+urakawa.hokkaido.jp
+urausu.hokkaido.jp
+uryu.hokkaido.jp
+utashinai.hokkaido.jp
+wakkanai.hokkaido.jp
+wassamu.hokkaido.jp
+yakumo.hokkaido.jp
+yoichi.hokkaido.jp
+aioi.hyogo.jp
+akashi.hyogo.jp
+ako.hyogo.jp
+amagasaki.hyogo.jp
+aogaki.hyogo.jp
+asago.hyogo.jp
+ashiya.hyogo.jp
+awaji.hyogo.jp
+fukusaki.hyogo.jp
+goshiki.hyogo.jp
+harima.hyogo.jp
+himeji.hyogo.jp
+ichikawa.hyogo.jp
+inagawa.hyogo.jp
+itami.hyogo.jp
+kakogawa.hyogo.jp
+kamigori.hyogo.jp
+kamikawa.hyogo.jp
+kasai.hyogo.jp
+kasuga.hyogo.jp
+kawanishi.hyogo.jp
+miki.hyogo.jp
+minamiawaji.hyogo.jp
+nishinomiya.hyogo.jp
+nishiwaki.hyogo.jp
+ono.hyogo.jp
+sanda.hyogo.jp
+sannan.hyogo.jp
+sasayama.hyogo.jp
+sayo.hyogo.jp
+shingu.hyogo.jp
+shinonsen.hyogo.jp
+shiso.hyogo.jp
+sumoto.hyogo.jp
+taishi.hyogo.jp
+taka.hyogo.jp
+takarazuka.hyogo.jp
+takasago.hyogo.jp
+takino.hyogo.jp
+tamba.hyogo.jp
+tatsuno.hyogo.jp
+toyooka.hyogo.jp
+yabu.hyogo.jp
+yashiro.hyogo.jp
+yoka.hyogo.jp
+yokawa.hyogo.jp
+ami.ibaraki.jp
+asahi.ibaraki.jp
+bando.ibaraki.jp
+chikusei.ibaraki.jp
+daigo.ibaraki.jp
+fujishiro.ibaraki.jp
+hitachi.ibaraki.jp
+hitachinaka.ibaraki.jp
+hitachiomiya.ibaraki.jp
+hitachiota.ibaraki.jp
+ibaraki.ibaraki.jp
+ina.ibaraki.jp
+inashiki.ibaraki.jp
+itako.ibaraki.jp
+iwama.ibaraki.jp
+joso.ibaraki.jp
+kamisu.ibaraki.jp
+kasama.ibaraki.jp
+kashima.ibaraki.jp
+kasumigaura.ibaraki.jp
+koga.ibaraki.jp
+miho.ibaraki.jp
+mito.ibaraki.jp
+moriya.ibaraki.jp
+naka.ibaraki.jp
+namegata.ibaraki.jp
+oarai.ibaraki.jp
+ogawa.ibaraki.jp
+omitama.ibaraki.jp
+ryugasaki.ibaraki.jp
+sakai.ibaraki.jp
+sakuragawa.ibaraki.jp
+shimodate.ibaraki.jp
+shimotsuma.ibaraki.jp
+shirosato.ibaraki.jp
+sowa.ibaraki.jp
+suifu.ibaraki.jp
+takahagi.ibaraki.jp
+tamatsukuri.ibaraki.jp
+tokai.ibaraki.jp
+tomobe.ibaraki.jp
+tone.ibaraki.jp
+toride.ibaraki.jp
+tsuchiura.ibaraki.jp
+tsukuba.ibaraki.jp
+uchihara.ibaraki.jp
+ushiku.ibaraki.jp
+yachiyo.ibaraki.jp
+yamagata.ibaraki.jp
+yawara.ibaraki.jp
+yuki.ibaraki.jp
+anamizu.ishikawa.jp
+hakui.ishikawa.jp
+hakusan.ishikawa.jp
+kaga.ishikawa.jp
+kahoku.ishikawa.jp
+kanazawa.ishikawa.jp
+kawakita.ishikawa.jp
+komatsu.ishikawa.jp
+nakanoto.ishikawa.jp
+nanao.ishikawa.jp
+nomi.ishikawa.jp
+nonoichi.ishikawa.jp
+noto.ishikawa.jp
+shika.ishikawa.jp
+suzu.ishikawa.jp
+tsubata.ishikawa.jp
+tsurugi.ishikawa.jp
+uchinada.ishikawa.jp
+wajima.ishikawa.jp
+fudai.iwate.jp
+fujisawa.iwate.jp
+hanamaki.iwate.jp
+hiraizumi.iwate.jp
+hirono.iwate.jp
+ichinohe.iwate.jp
+ichinoseki.iwate.jp
+iwaizumi.iwate.jp
+iwate.iwate.jp
+joboji.iwate.jp
+kamaishi.iwate.jp
+kanegasaki.iwate.jp
+karumai.iwate.jp
+kawai.iwate.jp
+kitakami.iwate.jp
+kuji.iwate.jp
+kunohe.iwate.jp
+kuzumaki.iwate.jp
+miyako.iwate.jp
+mizusawa.iwate.jp
+morioka.iwate.jp
+ninohe.iwate.jp
+noda.iwate.jp
+ofunato.iwate.jp
+oshu.iwate.jp
+otsuchi.iwate.jp
+rikuzentakata.iwate.jp
+shiwa.iwate.jp
+shizukuishi.iwate.jp
+sumita.iwate.jp
+tanohata.iwate.jp
+tono.iwate.jp
+yahaba.iwate.jp
+yamada.iwate.jp
+ayagawa.kagawa.jp
+higashikagawa.kagawa.jp
+kanonji.kagawa.jp
+kotohira.kagawa.jp
+manno.kagawa.jp
+marugame.kagawa.jp
+mitoyo.kagawa.jp
+naoshima.kagawa.jp
+sanuki.kagawa.jp
+tadotsu.kagawa.jp
+takamatsu.kagawa.jp
+tonosho.kagawa.jp
+uchinomi.kagawa.jp
+utazu.kagawa.jp
+zentsuji.kagawa.jp
+akune.kagoshima.jp
+amami.kagoshima.jp
+hioki.kagoshima.jp
+isa.kagoshima.jp
+isen.kagoshima.jp
+izumi.kagoshima.jp
+kagoshima.kagoshima.jp
+kanoya.kagoshima.jp
+kawanabe.kagoshima.jp
+kinko.kagoshima.jp
+kouyama.kagoshima.jp
+makurazaki.kagoshima.jp
+matsumoto.kagoshima.jp
+minamitane.kagoshima.jp
+nakatane.kagoshima.jp
+nishinoomote.kagoshima.jp
+satsumasendai.kagoshima.jp
+soo.kagoshima.jp
+tarumizu.kagoshima.jp
+yusui.kagoshima.jp
+aikawa.kanagawa.jp
+atsugi.kanagawa.jp
+ayase.kanagawa.jp
+chigasaki.kanagawa.jp
+ebina.kanagawa.jp
+fujisawa.kanagawa.jp
+hadano.kanagawa.jp
+hakone.kanagawa.jp
+hiratsuka.kanagawa.jp
+isehara.kanagawa.jp
+kaisei.kanagawa.jp
+kamakura.kanagawa.jp
+kiyokawa.kanagawa.jp
+matsuda.kanagawa.jp
+minamiashigara.kanagawa.jp
+miura.kanagawa.jp
+nakai.kanagawa.jp
+ninomiya.kanagawa.jp
+odawara.kanagawa.jp
+oi.kanagawa.jp
+oiso.kanagawa.jp
+sagamihara.kanagawa.jp
+samukawa.kanagawa.jp
+tsukui.kanagawa.jp
+yamakita.kanagawa.jp
+yamato.kanagawa.jp
+yokosuka.kanagawa.jp
+yugawara.kanagawa.jp
+zama.kanagawa.jp
+zushi.kanagawa.jp
+aki.kochi.jp
+geisei.kochi.jp
+hidaka.kochi.jp
+higashitsuno.kochi.jp
+ino.kochi.jp
+kagami.kochi.jp
+kami.kochi.jp
+kitagawa.kochi.jp
+kochi.kochi.jp
+mihara.kochi.jp
+motoyama.kochi.jp
+muroto.kochi.jp
+nahari.kochi.jp
+nakamura.kochi.jp
+nankoku.kochi.jp
+nishitosa.kochi.jp
+niyodogawa.kochi.jp
+ochi.kochi.jp
+okawa.kochi.jp
+otoyo.kochi.jp
+otsuki.kochi.jp
+sakawa.kochi.jp
+sukumo.kochi.jp
+susaki.kochi.jp
+tosa.kochi.jp
+tosashimizu.kochi.jp
+toyo.kochi.jp
+tsuno.kochi.jp
+umaji.kochi.jp
+yasuda.kochi.jp
+yusuhara.kochi.jp
+amakusa.kumamoto.jp
+arao.kumamoto.jp
+aso.kumamoto.jp
+choyo.kumamoto.jp
+gyokuto.kumamoto.jp
+kamiamakusa.kumamoto.jp
+kikuchi.kumamoto.jp
+kumamoto.kumamoto.jp
+mashiki.kumamoto.jp
+mifune.kumamoto.jp
+minamata.kumamoto.jp
+minamioguni.kumamoto.jp
+nagasu.kumamoto.jp
+nishihara.kumamoto.jp
+oguni.kumamoto.jp
+ozu.kumamoto.jp
+sumoto.kumamoto.jp
+takamori.kumamoto.jp
+uki.kumamoto.jp
+uto.kumamoto.jp
+yamaga.kumamoto.jp
+yamato.kumamoto.jp
+yatsushiro.kumamoto.jp
+ayabe.kyoto.jp
+fukuchiyama.kyoto.jp
+higashiyama.kyoto.jp
+ide.kyoto.jp
+ine.kyoto.jp
+joyo.kyoto.jp
+kameoka.kyoto.jp
+kamo.kyoto.jp
+kita.kyoto.jp
+kizu.kyoto.jp
+kumiyama.kyoto.jp
+kyotamba.kyoto.jp
+kyotanabe.kyoto.jp
+kyotango.kyoto.jp
+maizuru.kyoto.jp
+minami.kyoto.jp
+minamiyamashiro.kyoto.jp
+miyazu.kyoto.jp
+muko.kyoto.jp
+nagaokakyo.kyoto.jp
+nakagyo.kyoto.jp
+nantan.kyoto.jp
+oyamazaki.kyoto.jp
+sakyo.kyoto.jp
+seika.kyoto.jp
+tanabe.kyoto.jp
+uji.kyoto.jp
+ujitawara.kyoto.jp
+wazuka.kyoto.jp
+yamashina.kyoto.jp
+yawata.kyoto.jp
+asahi.mie.jp
+inabe.mie.jp
+ise.mie.jp
+kameyama.mie.jp
+kawagoe.mie.jp
+kiho.mie.jp
+kisosaki.mie.jp
+kiwa.mie.jp
+komono.mie.jp
+kumano.mie.jp
+kuwana.mie.jp
+matsusaka.mie.jp
+meiwa.mie.jp
+mihama.mie.jp
+minamiise.mie.jp
+misugi.mie.jp
+miyama.mie.jp
+nabari.mie.jp
+shima.mie.jp
+suzuka.mie.jp
+tado.mie.jp
+taiki.mie.jp
+taki.mie.jp
+tamaki.mie.jp
+toba.mie.jp
+tsu.mie.jp
+udono.mie.jp
+ureshino.mie.jp
+watarai.mie.jp
+yokkaichi.mie.jp
+furukawa.miyagi.jp
+higashimatsushima.miyagi.jp
+ishinomaki.miyagi.jp
+iwanuma.miyagi.jp
+kakuda.miyagi.jp
+kami.miyagi.jp
+kawasaki.miyagi.jp
+marumori.miyagi.jp
+matsushima.miyagi.jp
+minamisanriku.miyagi.jp
+misato.miyagi.jp
+murata.miyagi.jp
+natori.miyagi.jp
+ogawara.miyagi.jp
+ohira.miyagi.jp
+onagawa.miyagi.jp
+osaki.miyagi.jp
+rifu.miyagi.jp
+semine.miyagi.jp
+shibata.miyagi.jp
+shichikashuku.miyagi.jp
+shikama.miyagi.jp
+shiogama.miyagi.jp
+shiroishi.miyagi.jp
+tagajo.miyagi.jp
+taiwa.miyagi.jp
+tome.miyagi.jp
+tomiya.miyagi.jp
+wakuya.miyagi.jp
+watari.miyagi.jp
+yamamoto.miyagi.jp
+zao.miyagi.jp
+aya.miyazaki.jp
+ebino.miyazaki.jp
+gokase.miyazaki.jp
+hyuga.miyazaki.jp
+kadogawa.miyazaki.jp
+kawaminami.miyazaki.jp
+kijo.miyazaki.jp
+kitagawa.miyazaki.jp
+kitakata.miyazaki.jp
+kitaura.miyazaki.jp
+kobayashi.miyazaki.jp
+kunitomi.miyazaki.jp
+kushima.miyazaki.jp
+mimata.miyazaki.jp
+miyakonojo.miyazaki.jp
+miyazaki.miyazaki.jp
+morotsuka.miyazaki.jp
+nichinan.miyazaki.jp
+nishimera.miyazaki.jp
+nobeoka.miyazaki.jp
+saito.miyazaki.jp
+shiiba.miyazaki.jp
+shintomi.miyazaki.jp
+takaharu.miyazaki.jp
+takanabe.miyazaki.jp
+takazaki.miyazaki.jp
+tsuno.miyazaki.jp
+achi.nagano.jp
+agematsu.nagano.jp
+anan.nagano.jp
+aoki.nagano.jp
+asahi.nagano.jp
+azumino.nagano.jp
+chikuhoku.nagano.jp
+chikuma.nagano.jp
+chino.nagano.jp
+fujimi.nagano.jp
+hakuba.nagano.jp
+hara.nagano.jp
+hiraya.nagano.jp
+iida.nagano.jp
+iijima.nagano.jp
+iiyama.nagano.jp
+iizuna.nagano.jp
+ikeda.nagano.jp
+ikusaka.nagano.jp
+ina.nagano.jp
+karuizawa.nagano.jp
+kawakami.nagano.jp
+kiso.nagano.jp
+kisofukushima.nagano.jp
+kitaaiki.nagano.jp
+komagane.nagano.jp
+komoro.nagano.jp
+matsukawa.nagano.jp
+matsumoto.nagano.jp
+miasa.nagano.jp
+minamiaiki.nagano.jp
+minamimaki.nagano.jp
+minamiminowa.nagano.jp
+minowa.nagano.jp
+miyada.nagano.jp
+miyota.nagano.jp
+mochizuki.nagano.jp
+nagano.nagano.jp
+nagawa.nagano.jp
+nagiso.nagano.jp
+nakagawa.nagano.jp
+nakano.nagano.jp
+nozawaonsen.nagano.jp
+obuse.nagano.jp
+ogawa.nagano.jp
+okaya.nagano.jp
+omachi.nagano.jp
+omi.nagano.jp
+ookuwa.nagano.jp
+ooshika.nagano.jp
+otaki.nagano.jp
+otari.nagano.jp
+sakae.nagano.jp
+sakaki.nagano.jp
+saku.nagano.jp
+sakuho.nagano.jp
+shimosuwa.nagano.jp
+shinanomachi.nagano.jp
+shiojiri.nagano.jp
+suwa.nagano.jp
+suzaka.nagano.jp
+takagi.nagano.jp
+takamori.nagano.jp
+takayama.nagano.jp
+tateshina.nagano.jp
+tatsuno.nagano.jp
+togakushi.nagano.jp
+togura.nagano.jp
+tomi.nagano.jp
+ueda.nagano.jp
+wada.nagano.jp
+yamagata.nagano.jp
+yamanouchi.nagano.jp
+yasaka.nagano.jp
+yasuoka.nagano.jp
+chijiwa.nagasaki.jp
+futsu.nagasaki.jp
+goto.nagasaki.jp
+hasami.nagasaki.jp
+hirado.nagasaki.jp
+iki.nagasaki.jp
+isahaya.nagasaki.jp
+kawatana.nagasaki.jp
+kuchinotsu.nagasaki.jp
+matsuura.nagasaki.jp
+nagasaki.nagasaki.jp
+obama.nagasaki.jp
+omura.nagasaki.jp
+oseto.nagasaki.jp
+saikai.nagasaki.jp
+sasebo.nagasaki.jp
+seihi.nagasaki.jp
+shimabara.nagasaki.jp
+shinkamigoto.nagasaki.jp
+togitsu.nagasaki.jp
+tsushima.nagasaki.jp
+unzen.nagasaki.jp
+ando.nara.jp
+gose.nara.jp
+heguri.nara.jp
+higashiyoshino.nara.jp
+ikaruga.nara.jp
+ikoma.nara.jp
+kamikitayama.nara.jp
+kanmaki.nara.jp
+kashiba.nara.jp
+kashihara.nara.jp
+katsuragi.nara.jp
+kawai.nara.jp
+kawakami.nara.jp
+kawanishi.nara.jp
+koryo.nara.jp
+kurotaki.nara.jp
+mitsue.nara.jp
+miyake.nara.jp
+nara.nara.jp
+nosegawa.nara.jp
+oji.nara.jp
+ouda.nara.jp
+oyodo.nara.jp
+sakurai.nara.jp
+sango.nara.jp
+shimoichi.nara.jp
+shimokitayama.nara.jp
+shinjo.nara.jp
+soni.nara.jp
+takatori.nara.jp
+tawaramoto.nara.jp
+tenkawa.nara.jp
+tenri.nara.jp
+uda.nara.jp
+yamatokoriyama.nara.jp
+yamatotakada.nara.jp
+yamazoe.nara.jp
+yoshino.nara.jp
+aga.niigata.jp
+agano.niigata.jp
+gosen.niigata.jp
+itoigawa.niigata.jp
+izumozaki.niigata.jp
+joetsu.niigata.jp
+kamo.niigata.jp
+kariwa.niigata.jp
+kashiwazaki.niigata.jp
+minamiuonuma.niigata.jp
+mitsuke.niigata.jp
+muika.niigata.jp
+murakami.niigata.jp
+myoko.niigata.jp
+nagaoka.niigata.jp
+niigata.niigata.jp
+ojiya.niigata.jp
+omi.niigata.jp
+sado.niigata.jp
+sanjo.niigata.jp
+seiro.niigata.jp
+seirou.niigata.jp
+sekikawa.niigata.jp
+shibata.niigata.jp
+tagami.niigata.jp
+tainai.niigata.jp
+tochio.niigata.jp
+tokamachi.niigata.jp
+tsubame.niigata.jp
+tsunan.niigata.jp
+uonuma.niigata.jp
+yahiko.niigata.jp
+yoita.niigata.jp
+yuzawa.niigata.jp
+beppu.oita.jp
+bungoono.oita.jp
+bungotakada.oita.jp
+hasama.oita.jp
+hiji.oita.jp
+himeshima.oita.jp
+hita.oita.jp
+kamitsue.oita.jp
+kokonoe.oita.jp
+kuju.oita.jp
+kunisaki.oita.jp
+kusu.oita.jp
+oita.oita.jp
+saiki.oita.jp
+taketa.oita.jp
+tsukumi.oita.jp
+usa.oita.jp
+usuki.oita.jp
+yufu.oita.jp
+akaiwa.okayama.jp
+asakuchi.okayama.jp
+bizen.okayama.jp
+hayashima.okayama.jp
+ibara.okayama.jp
+kagamino.okayama.jp
+kasaoka.okayama.jp
+kibichuo.okayama.jp
+kumenan.okayama.jp
+kurashiki.okayama.jp
+maniwa.okayama.jp
+misaki.okayama.jp
+nagi.okayama.jp
+niimi.okayama.jp
+nishiawakura.okayama.jp
+okayama.okayama.jp
+satosho.okayama.jp
+setouchi.okayama.jp
+shinjo.okayama.jp
+shoo.okayama.jp
+soja.okayama.jp
+takahashi.okayama.jp
+tamano.okayama.jp
+tsuyama.okayama.jp
+wake.okayama.jp
+yakage.okayama.jp
+aguni.okinawa.jp
+ginowan.okinawa.jp
+ginoza.okinawa.jp
+gushikami.okinawa.jp
+haebaru.okinawa.jp
+higashi.okinawa.jp
+hirara.okinawa.jp
+iheya.okinawa.jp
+ishigaki.okinawa.jp
+ishikawa.okinawa.jp
+itoman.okinawa.jp
+izena.okinawa.jp
+kadena.okinawa.jp
+kin.okinawa.jp
+kitadaito.okinawa.jp
+kitanakagusuku.okinawa.jp
+kumejima.okinawa.jp
+kunigami.okinawa.jp
+minamidaito.okinawa.jp
+motobu.okinawa.jp
+nago.okinawa.jp
+naha.okinawa.jp
+nakagusuku.okinawa.jp
+nakijin.okinawa.jp
+nanjo.okinawa.jp
+nishihara.okinawa.jp
+ogimi.okinawa.jp
+okinawa.okinawa.jp
+onna.okinawa.jp
+shimoji.okinawa.jp
+taketomi.okinawa.jp
+tarama.okinawa.jp
+tokashiki.okinawa.jp
+tomigusuku.okinawa.jp
+tonaki.okinawa.jp
+urasoe.okinawa.jp
+uruma.okinawa.jp
+yaese.okinawa.jp
+yomitan.okinawa.jp
+yonabaru.okinawa.jp
+yonaguni.okinawa.jp
+zamami.okinawa.jp
+abeno.osaka.jp
+chihayaakasaka.osaka.jp
+chuo.osaka.jp
+daito.osaka.jp
+fujiidera.osaka.jp
+habikino.osaka.jp
+hannan.osaka.jp
+higashiosaka.osaka.jp
+higashisumiyoshi.osaka.jp
+higashiyodogawa.osaka.jp
+hirakata.osaka.jp
+ibaraki.osaka.jp
+ikeda.osaka.jp
+izumi.osaka.jp
+izumiotsu.osaka.jp
+izumisano.osaka.jp
+kadoma.osaka.jp
+kaizuka.osaka.jp
+kanan.osaka.jp
+kashiwara.osaka.jp
+katano.osaka.jp
+kawachinagano.osaka.jp
+kishiwada.osaka.jp
+kita.osaka.jp
+kumatori.osaka.jp
+matsubara.osaka.jp
+minato.osaka.jp
+minoh.osaka.jp
+misaki.osaka.jp
+moriguchi.osaka.jp
+neyagawa.osaka.jp
+nishi.osaka.jp
+nose.osaka.jp
+osakasayama.osaka.jp
+sakai.osaka.jp
+sayama.osaka.jp
+sennan.osaka.jp
+settsu.osaka.jp
+shijonawate.osaka.jp
+shimamoto.osaka.jp
+suita.osaka.jp
+tadaoka.osaka.jp
+taishi.osaka.jp
+tajiri.osaka.jp
+takaishi.osaka.jp
+takatsuki.osaka.jp
+tondabayashi.osaka.jp
+toyonaka.osaka.jp
+toyono.osaka.jp
+yao.osaka.jp
+ariake.saga.jp
+arita.saga.jp
+fukudomi.saga.jp
+genkai.saga.jp
+hamatama.saga.jp
+hizen.saga.jp
+imari.saga.jp
+kamimine.saga.jp
+kanzaki.saga.jp
+karatsu.saga.jp
+kashima.saga.jp
+kitagata.saga.jp
+kitahata.saga.jp
+kiyama.saga.jp
+kouhoku.saga.jp
+kyuragi.saga.jp
+nishiarita.saga.jp
+ogi.saga.jp
+omachi.saga.jp
+ouchi.saga.jp
+saga.saga.jp
+shiroishi.saga.jp
+taku.saga.jp
+tara.saga.jp
+tosu.saga.jp
+yoshinogari.saga.jp
+arakawa.saitama.jp
+asaka.saitama.jp
+chichibu.saitama.jp
+fujimi.saitama.jp
+fujimino.saitama.jp
+fukaya.saitama.jp
+hanno.saitama.jp
+hanyu.saitama.jp
+hasuda.saitama.jp
+hatogaya.saitama.jp
+hatoyama.saitama.jp
+hidaka.saitama.jp
+higashichichibu.saitama.jp
+higashimatsuyama.saitama.jp
+honjo.saitama.jp
+ina.saitama.jp
+iruma.saitama.jp
+iwatsuki.saitama.jp
+kamiizumi.saitama.jp
+kamikawa.saitama.jp
+kamisato.saitama.jp
+kasukabe.saitama.jp
+kawagoe.saitama.jp
+kawaguchi.saitama.jp
+kawajima.saitama.jp
+kazo.saitama.jp
+kitamoto.saitama.jp
+koshigaya.saitama.jp
+kounosu.saitama.jp
+kuki.saitama.jp
+kumagaya.saitama.jp
+matsubushi.saitama.jp
+minano.saitama.jp
+misato.saitama.jp
+miyashiro.saitama.jp
+miyoshi.saitama.jp
+moroyama.saitama.jp
+nagatoro.saitama.jp
+namegawa.saitama.jp
+niiza.saitama.jp
+ogano.saitama.jp
+ogawa.saitama.jp
+ogose.saitama.jp
+okegawa.saitama.jp
+omiya.saitama.jp
+otaki.saitama.jp
+ranzan.saitama.jp
+ryokami.saitama.jp
+saitama.saitama.jp
+sakado.saitama.jp
+satte.saitama.jp
+sayama.saitama.jp
+shiki.saitama.jp
+shiraoka.saitama.jp
+soka.saitama.jp
+sugito.saitama.jp
+toda.saitama.jp
+tokigawa.saitama.jp
+tokorozawa.saitama.jp
+tsurugashima.saitama.jp
+urawa.saitama.jp
+warabi.saitama.jp
+yashio.saitama.jp
+yokoze.saitama.jp
+yono.saitama.jp
+yorii.saitama.jp
+yoshida.saitama.jp
+yoshikawa.saitama.jp
+yoshimi.saitama.jp
+aisho.shiga.jp
+gamo.shiga.jp
+higashiomi.shiga.jp
+hikone.shiga.jp
+koka.shiga.jp
+konan.shiga.jp
+kosei.shiga.jp
+koto.shiga.jp
+kusatsu.shiga.jp
+maibara.shiga.jp
+moriyama.shiga.jp
+nagahama.shiga.jp
+nishiazai.shiga.jp
+notogawa.shiga.jp
+omihachiman.shiga.jp
+otsu.shiga.jp
+ritto.shiga.jp
+ryuoh.shiga.jp
+takashima.shiga.jp
+takatsuki.shiga.jp
+torahime.shiga.jp
+toyosato.shiga.jp
+yasu.shiga.jp
+akagi.shimane.jp
+ama.shimane.jp
+gotsu.shimane.jp
+hamada.shimane.jp
+higashiizumo.shimane.jp
+hikawa.shimane.jp
+hikimi.shimane.jp
+izumo.shimane.jp
+kakinoki.shimane.jp
+masuda.shimane.jp
+matsue.shimane.jp
+misato.shimane.jp
+nishinoshima.shimane.jp
+ohda.shimane.jp
+okinoshima.shimane.jp
+okuizumo.shimane.jp
+shimane.shimane.jp
+tamayu.shimane.jp
+tsuwano.shimane.jp
+unnan.shimane.jp
+yakumo.shimane.jp
+yasugi.shimane.jp
+yatsuka.shimane.jp
+arai.shizuoka.jp
+atami.shizuoka.jp
+fuji.shizuoka.jp
+fujieda.shizuoka.jp
+fujikawa.shizuoka.jp
+fujinomiya.shizuoka.jp
+fukuroi.shizuoka.jp
+gotemba.shizuoka.jp
+haibara.shizuoka.jp
+hamamatsu.shizuoka.jp
+higashiizu.shizuoka.jp
+ito.shizuoka.jp
+iwata.shizuoka.jp
+izu.shizuoka.jp
+izunokuni.shizuoka.jp
+kakegawa.shizuoka.jp
+kannami.shizuoka.jp
+kawanehon.shizuoka.jp
+kawazu.shizuoka.jp
+kikugawa.shizuoka.jp
+kosai.shizuoka.jp
+makinohara.shizuoka.jp
+matsuzaki.shizuoka.jp
+minamiizu.shizuoka.jp
+mishima.shizuoka.jp
+morimachi.shizuoka.jp
+nishiizu.shizuoka.jp
+numazu.shizuoka.jp
+omaezaki.shizuoka.jp
+shimada.shizuoka.jp
+shimizu.shizuoka.jp
+shimoda.shizuoka.jp
+shizuoka.shizuoka.jp
+susono.shizuoka.jp
+yaizu.shizuoka.jp
+yoshida.shizuoka.jp
+ashikaga.tochigi.jp
+bato.tochigi.jp
+haga.tochigi.jp
+ichikai.tochigi.jp
+iwafune.tochigi.jp
+kaminokawa.tochigi.jp
+kanuma.tochigi.jp
+karasuyama.tochigi.jp
+kuroiso.tochigi.jp
+mashiko.tochigi.jp
+mibu.tochigi.jp
+moka.tochigi.jp
+motegi.tochigi.jp
+nasu.tochigi.jp
+nasushiobara.tochigi.jp
+nikko.tochigi.jp
+nishikata.tochigi.jp
+nogi.tochigi.jp
+ohira.tochigi.jp
+ohtawara.tochigi.jp
+oyama.tochigi.jp
+sakura.tochigi.jp
+sano.tochigi.jp
+shimotsuke.tochigi.jp
+shioya.tochigi.jp
+takanezawa.tochigi.jp
+tochigi.tochigi.jp
+tsuga.tochigi.jp
+ujiie.tochigi.jp
+utsunomiya.tochigi.jp
+yaita.tochigi.jp
+aizumi.tokushima.jp
+anan.tokushima.jp
+ichiba.tokushima.jp
+itano.tokushima.jp
+kainan.tokushima.jp
+komatsushima.tokushima.jp
+matsushige.tokushima.jp
+mima.tokushima.jp
+minami.tokushima.jp
+miyoshi.tokushima.jp
+mugi.tokushima.jp
+nakagawa.tokushima.jp
+naruto.tokushima.jp
+sanagochi.tokushima.jp
+shishikui.tokushima.jp
+tokushima.tokushima.jp
+wajiki.tokushima.jp
+adachi.tokyo.jp
+akiruno.tokyo.jp
+akishima.tokyo.jp
+aogashima.tokyo.jp
+arakawa.tokyo.jp
+bunkyo.tokyo.jp
+chiyoda.tokyo.jp
+chofu.tokyo.jp
+chuo.tokyo.jp
+edogawa.tokyo.jp
+fuchu.tokyo.jp
+fussa.tokyo.jp
+hachijo.tokyo.jp
+hachioji.tokyo.jp
+hamura.tokyo.jp
+higashikurume.tokyo.jp
+higashimurayama.tokyo.jp
+higashiyamato.tokyo.jp
+hino.tokyo.jp
+hinode.tokyo.jp
+hinohara.tokyo.jp
+inagi.tokyo.jp
+itabashi.tokyo.jp
+katsushika.tokyo.jp
+kita.tokyo.jp
+kiyose.tokyo.jp
+kodaira.tokyo.jp
+koganei.tokyo.jp
+kokubunji.tokyo.jp
+komae.tokyo.jp
+koto.tokyo.jp
+kouzushima.tokyo.jp
+kunitachi.tokyo.jp
+machida.tokyo.jp
+meguro.tokyo.jp
+minato.tokyo.jp
+mitaka.tokyo.jp
+mizuho.tokyo.jp
+musashimurayama.tokyo.jp
+musashino.tokyo.jp
+nakano.tokyo.jp
+nerima.tokyo.jp
+ogasawara.tokyo.jp
+okutama.tokyo.jp
+ome.tokyo.jp
+oshima.tokyo.jp
+ota.tokyo.jp
+setagaya.tokyo.jp
+shibuya.tokyo.jp
+shinagawa.tokyo.jp
+shinjuku.tokyo.jp
+suginami.tokyo.jp
+sumida.tokyo.jp
+tachikawa.tokyo.jp
+taito.tokyo.jp
+tama.tokyo.jp
+toshima.tokyo.jp
+chizu.tottori.jp
+hino.tottori.jp
+kawahara.tottori.jp
+koge.tottori.jp
+kotoura.tottori.jp
+misasa.tottori.jp
+nanbu.tottori.jp
+nichinan.tottori.jp
+sakaiminato.tottori.jp
+tottori.tottori.jp
+wakasa.tottori.jp
+yazu.tottori.jp
+yonago.tottori.jp
+asahi.toyama.jp
+fuchu.toyama.jp
+fukumitsu.toyama.jp
+funahashi.toyama.jp
+himi.toyama.jp
+imizu.toyama.jp
+inami.toyama.jp
+johana.toyama.jp
+kamiichi.toyama.jp
+kurobe.toyama.jp
+nakaniikawa.toyama.jp
+namerikawa.toyama.jp
+nanto.toyama.jp
+nyuzen.toyama.jp
+oyabe.toyama.jp
+taira.toyama.jp
+takaoka.toyama.jp
+tateyama.toyama.jp
+toga.toyama.jp
+tonami.toyama.jp
+toyama.toyama.jp
+unazuki.toyama.jp
+uozu.toyama.jp
+yamada.toyama.jp
+arida.wakayama.jp
+aridagawa.wakayama.jp
+gobo.wakayama.jp
+hashimoto.wakayama.jp
+hidaka.wakayama.jp
+hirogawa.wakayama.jp
+inami.wakayama.jp
+iwade.wakayama.jp
+kainan.wakayama.jp
+kamitonda.wakayama.jp
+katsuragi.wakayama.jp
+kimino.wakayama.jp
+kinokawa.wakayama.jp
+kitayama.wakayama.jp
+koya.wakayama.jp
+koza.wakayama.jp
+kozagawa.wakayama.jp
+kudoyama.wakayama.jp
+kushimoto.wakayama.jp
+mihama.wakayama.jp
+misato.wakayama.jp
+nachikatsuura.wakayama.jp
+shingu.wakayama.jp
+shirahama.wakayama.jp
+taiji.wakayama.jp
+tanabe.wakayama.jp
+wakayama.wakayama.jp
+yuasa.wakayama.jp
+yura.wakayama.jp
+asahi.yamagata.jp
+funagata.yamagata.jp
+higashine.yamagata.jp
+iide.yamagata.jp
+kahoku.yamagata.jp
+kaminoyama.yamagata.jp
+kaneyama.yamagata.jp
+kawanishi.yamagata.jp
+mamurogawa.yamagata.jp
+mikawa.yamagata.jp
+murayama.yamagata.jp
+nagai.yamagata.jp
+nakayama.yamagata.jp
+nanyo.yamagata.jp
+nishikawa.yamagata.jp
+obanazawa.yamagata.jp
+oe.yamagata.jp
+oguni.yamagata.jp
+ohkura.yamagata.jp
+oishida.yamagata.jp
+sagae.yamagata.jp
+sakata.yamagata.jp
+sakegawa.yamagata.jp
+shinjo.yamagata.jp
+shirataka.yamagata.jp
+shonai.yamagata.jp
+takahata.yamagata.jp
+tendo.yamagata.jp
+tozawa.yamagata.jp
+tsuruoka.yamagata.jp
+yamagata.yamagata.jp
+yamanobe.yamagata.jp
+yonezawa.yamagata.jp
+yuza.yamagata.jp
+abu.yamaguchi.jp
+hagi.yamaguchi.jp
+hikari.yamaguchi.jp
+hofu.yamaguchi.jp
+iwakuni.yamaguchi.jp
+kudamatsu.yamaguchi.jp
+mitou.yamaguchi.jp
+nagato.yamaguchi.jp
+oshima.yamaguchi.jp
+shimonoseki.yamaguchi.jp
+shunan.yamaguchi.jp
+tabuse.yamaguchi.jp
+tokuyama.yamaguchi.jp
+toyota.yamaguchi.jp
+ube.yamaguchi.jp
+yuu.yamaguchi.jp
+chuo.yamanashi.jp
+doshi.yamanashi.jp
+fuefuki.yamanashi.jp
+fujikawa.yamanashi.jp
+fujikawaguchiko.yamanashi.jp
+fujiyoshida.yamanashi.jp
+hayakawa.yamanashi.jp
+hokuto.yamanashi.jp
+ichikawamisato.yamanashi.jp
+kai.yamanashi.jp
+kofu.yamanashi.jp
+koshu.yamanashi.jp
+kosuge.yamanashi.jp
+minami-alps.yamanashi.jp
+minobu.yamanashi.jp
+nakamichi.yamanashi.jp
+nanbu.yamanashi.jp
+narusawa.yamanashi.jp
+nirasaki.yamanashi.jp
+nishikatsura.yamanashi.jp
+oshino.yamanashi.jp
+otsuki.yamanashi.jp
+showa.yamanashi.jp
+tabayama.yamanashi.jp
+tsuru.yamanashi.jp
+uenohara.yamanashi.jp
+yamanakako.yamanashi.jp
+yamanashi.yamanashi.jp
+
+// ke : http://www.kenic.or.ke/index.php/en/ke-domains/ke-domains
+ke
+ac.ke
+co.ke
+go.ke
+info.ke
+me.ke
+mobi.ke
+ne.ke
+or.ke
+sc.ke
+
+// kg : http://www.domain.kg/dmn_n.html
+kg
+org.kg
+net.kg
+com.kg
+edu.kg
+gov.kg
+mil.kg
+
+// kh : http://www.mptc.gov.kh/dns_registration.htm
+*.kh
+
+// ki : http://www.ki/dns/index.html
+ki
+edu.ki
+biz.ki
+net.ki
+org.ki
+gov.ki
+info.ki
+com.ki
+
+// km : https://en.wikipedia.org/wiki/.km
+// http://www.domaine.km/documents/charte.doc
+km
+org.km
+nom.km
+gov.km
+prd.km
+tm.km
+edu.km
+mil.km
+ass.km
+com.km
+// These are only mentioned as proposed suggestions at domaine.km, but
+// https://en.wikipedia.org/wiki/.km says they're available for registration:
+coop.km
+asso.km
+presse.km
+medecin.km
+notaires.km
+pharmaciens.km
+veterinaire.km
+gouv.km
+
+// kn : https://en.wikipedia.org/wiki/.kn
+// http://www.dot.kn/domainRules.html
+kn
+net.kn
+org.kn
+edu.kn
+gov.kn
+
+// kp : http://www.kcce.kp/en_index.php
+kp
+com.kp
+edu.kp
+gov.kp
+org.kp
+rep.kp
+tra.kp
+
+// kr : https://en.wikipedia.org/wiki/.kr
+// see also: http://domain.nida.or.kr/eng/registration.jsp
+kr
+ac.kr
+co.kr
+es.kr
+go.kr
+hs.kr
+kg.kr
+mil.kr
+ms.kr
+ne.kr
+or.kr
+pe.kr
+re.kr
+sc.kr
+// kr geographical names
+busan.kr
+chungbuk.kr
+chungnam.kr
+daegu.kr
+daejeon.kr
+gangwon.kr
+gwangju.kr
+gyeongbuk.kr
+gyeonggi.kr
+gyeongnam.kr
+incheon.kr
+jeju.kr
+jeonbuk.kr
+jeonnam.kr
+seoul.kr
+ulsan.kr
+
+// kw : https://www.nic.kw/policies/
+// Confirmed by registry <nic.tech@citra.gov.kw>
+kw
+com.kw
+edu.kw
+emb.kw
+gov.kw
+ind.kw
+net.kw
+org.kw
+
+// ky : http://www.icta.ky/da_ky_reg_dom.php
+// Confirmed by registry <kysupport@perimeterusa.com> 2008-06-17
+ky
+edu.ky
+gov.ky
+com.ky
+org.ky
+net.ky
+
+// kz : https://en.wikipedia.org/wiki/.kz
+// see also: http://www.nic.kz/rules/index.jsp
+kz
+org.kz
+edu.kz
+net.kz
+gov.kz
+mil.kz
+com.kz
+
+// la : https://en.wikipedia.org/wiki/.la
+// Submitted by registry <gavin.brown@nic.la>
+la
+int.la
+net.la
+info.la
+edu.la
+gov.la
+per.la
+com.la
+org.la
+
+// lb : https://en.wikipedia.org/wiki/.lb
+// Submitted by registry <randy@psg.com>
+lb
+com.lb
+edu.lb
+gov.lb
+net.lb
+org.lb
+
+// lc : https://en.wikipedia.org/wiki/.lc
+// see also: http://www.nic.lc/rules.htm
+lc
+com.lc
+net.lc
+co.lc
+org.lc
+edu.lc
+gov.lc
+
+// li : https://en.wikipedia.org/wiki/.li
+li
+
+// lk : http://www.nic.lk/seclevpr.html
+lk
+gov.lk
+sch.lk
+net.lk
+int.lk
+com.lk
+org.lk
+edu.lk
+ngo.lk
+soc.lk
+web.lk
+ltd.lk
+assn.lk
+grp.lk
+hotel.lk
+ac.lk
+
+// lr : http://psg.com/dns/lr/lr.txt
+// Submitted by registry <randy@psg.com>
+lr
+com.lr
+edu.lr
+gov.lr
+org.lr
+net.lr
+
+// ls : http://www.nic.ls/
+// Confirmed by registry <lsadmin@nic.ls>
+ls
+ac.ls
+biz.ls
+co.ls
+edu.ls
+gov.ls
+info.ls
+net.ls
+org.ls
+sc.ls
+
+// lt : https://en.wikipedia.org/wiki/.lt
+lt
+// gov.lt : http://www.gov.lt/index_en.php
+gov.lt
+
+// lu : http://www.dns.lu/en/
+lu
+
+// lv : http://www.nic.lv/DNS/En/generic.php
+lv
+com.lv
+edu.lv
+gov.lv
+org.lv
+mil.lv
+id.lv
+net.lv
+asn.lv
+conf.lv
+
+// ly : http://www.nic.ly/regulations.php
+ly
+com.ly
+net.ly
+gov.ly
+plc.ly
+edu.ly
+sch.ly
+med.ly
+org.ly
+id.ly
+
+// ma : https://en.wikipedia.org/wiki/.ma
+// http://www.anrt.ma/fr/admin/download/upload/file_fr782.pdf
+ma
+co.ma
+net.ma
+gov.ma
+org.ma
+ac.ma
+press.ma
+
+// mc : http://www.nic.mc/
+mc
+tm.mc
+asso.mc
+
+// md : https://en.wikipedia.org/wiki/.md
+md
+
+// me : https://en.wikipedia.org/wiki/.me
+me
+co.me
+net.me
+org.me
+edu.me
+ac.me
+gov.me
+its.me
+priv.me
+
+// mg : http://nic.mg/nicmg/?page_id=39
+mg
+org.mg
+nom.mg
+gov.mg
+prd.mg
+tm.mg
+edu.mg
+mil.mg
+com.mg
+co.mg
+
+// mh : https://en.wikipedia.org/wiki/.mh
+mh
+
+// mil : https://en.wikipedia.org/wiki/.mil
+mil
+
+// mk : https://en.wikipedia.org/wiki/.mk
+// see also: http://dns.marnet.net.mk/postapka.php
+mk
+com.mk
+org.mk
+net.mk
+edu.mk
+gov.mk
+inf.mk
+name.mk
+
+// ml : http://www.gobin.info/domainname/ml-template.doc
+// see also: https://en.wikipedia.org/wiki/.ml
+ml
+com.ml
+edu.ml
+gouv.ml
+gov.ml
+net.ml
+org.ml
+presse.ml
+
+// mm : https://en.wikipedia.org/wiki/.mm
+*.mm
+
+// mn : https://en.wikipedia.org/wiki/.mn
+mn
+gov.mn
+edu.mn
+org.mn
+
+// mo : http://www.monic.net.mo/
+mo
+com.mo
+net.mo
+org.mo
+edu.mo
+gov.mo
+
+// mobi : https://en.wikipedia.org/wiki/.mobi
+mobi
+
+// mp : http://www.dot.mp/
+// Confirmed by registry <dcamacho@saipan.com> 2008-06-17
+mp
+
+// mq : https://en.wikipedia.org/wiki/.mq
+mq
+
+// mr : https://en.wikipedia.org/wiki/.mr
+mr
+gov.mr
+
+// ms : http://www.nic.ms/pdf/MS_Domain_Name_Rules.pdf
+ms
+com.ms
+edu.ms
+gov.ms
+net.ms
+org.ms
+
+// mt : https://www.nic.org.mt/go/policy
+// Submitted by registry <help@nic.org.mt>
+mt
+com.mt
+edu.mt
+net.mt
+org.mt
+
+// mu : https://en.wikipedia.org/wiki/.mu
+mu
+com.mu
+net.mu
+org.mu
+gov.mu
+ac.mu
+co.mu
+or.mu
+
+// museum : http://about.museum/naming/
+// http://index.museum/
+museum
+academy.museum
+agriculture.museum
+air.museum
+airguard.museum
+alabama.museum
+alaska.museum
+amber.museum
+ambulance.museum
+american.museum
+americana.museum
+americanantiques.museum
+americanart.museum
+amsterdam.museum
+and.museum
+annefrank.museum
+anthro.museum
+anthropology.museum
+antiques.museum
+aquarium.museum
+arboretum.museum
+archaeological.museum
+archaeology.museum
+architecture.museum
+art.museum
+artanddesign.museum
+artcenter.museum
+artdeco.museum
+arteducation.museum
+artgallery.museum
+arts.museum
+artsandcrafts.museum
+asmatart.museum
+assassination.museum
+assisi.museum
+association.museum
+astronomy.museum
+atlanta.museum
+austin.museum
+australia.museum
+automotive.museum
+aviation.museum
+axis.museum
+badajoz.museum
+baghdad.museum
+bahn.museum
+bale.museum
+baltimore.museum
+barcelona.museum
+baseball.museum
+basel.museum
+baths.museum
+bauern.museum
+beauxarts.museum
+beeldengeluid.museum
+bellevue.museum
+bergbau.museum
+berkeley.museum
+berlin.museum
+bern.museum
+bible.museum
+bilbao.museum
+bill.museum
+birdart.museum
+birthplace.museum
+bonn.museum
+boston.museum
+botanical.museum
+botanicalgarden.museum
+botanicgarden.museum
+botany.museum
+brandywinevalley.museum
+brasil.museum
+bristol.museum
+british.museum
+britishcolumbia.museum
+broadcast.museum
+brunel.museum
+brussel.museum
+brussels.museum
+bruxelles.museum
+building.museum
+burghof.museum
+bus.museum
+bushey.museum
+cadaques.museum
+california.museum
+cambridge.museum
+can.museum
+canada.museum
+capebreton.museum
+carrier.museum
+cartoonart.museum
+casadelamoneda.museum
+castle.museum
+castres.museum
+celtic.museum
+center.museum
+chattanooga.museum
+cheltenham.museum
+chesapeakebay.museum
+chicago.museum
+children.museum
+childrens.museum
+childrensgarden.museum
+chiropractic.museum
+chocolate.museum
+christiansburg.museum
+cincinnati.museum
+cinema.museum
+circus.museum
+civilisation.museum
+civilization.museum
+civilwar.museum
+clinton.museum
+clock.museum
+coal.museum
+coastaldefence.museum
+cody.museum
+coldwar.museum
+collection.museum
+colonialwilliamsburg.museum
+coloradoplateau.museum
+columbia.museum
+columbus.museum
+communication.museum
+communications.museum
+community.museum
+computer.museum
+computerhistory.museum
+comunicações.museum
+contemporary.museum
+contemporaryart.museum
+convent.museum
+copenhagen.museum
+corporation.museum
+correios-e-telecomunicações.museum
+corvette.museum
+costume.museum
+countryestate.museum
+county.museum
+crafts.museum
+cranbrook.museum
+creation.museum
+cultural.museum
+culturalcenter.museum
+culture.museum
+cyber.museum
+cymru.museum
+dali.museum
+dallas.museum
+database.museum
+ddr.museum
+decorativearts.museum
+delaware.museum
+delmenhorst.museum
+denmark.museum
+depot.museum
+design.museum
+detroit.museum
+dinosaur.museum
+discovery.museum
+dolls.museum
+donostia.museum
+durham.museum
+eastafrica.museum
+eastcoast.museum
+education.museum
+educational.museum
+egyptian.museum
+eisenbahn.museum
+elburg.museum
+elvendrell.museum
+embroidery.museum
+encyclopedic.museum
+england.museum
+entomology.museum
+environment.museum
+environmentalconservation.museum
+epilepsy.museum
+essex.museum
+estate.museum
+ethnology.museum
+exeter.museum
+exhibition.museum
+family.museum
+farm.museum
+farmequipment.museum
+farmers.museum
+farmstead.museum
+field.museum
+figueres.museum
+filatelia.museum
+film.museum
+fineart.museum
+finearts.museum
+finland.museum
+flanders.museum
+florida.museum
+force.museum
+fortmissoula.museum
+fortworth.museum
+foundation.museum
+francaise.museum
+frankfurt.museum
+franziskaner.museum
+freemasonry.museum
+freiburg.museum
+fribourg.museum
+frog.museum
+fundacio.museum
+furniture.museum
+gallery.museum
+garden.museum
+gateway.museum
+geelvinck.museum
+gemological.museum
+geology.museum
+georgia.museum
+giessen.museum
+glas.museum
+glass.museum
+gorge.museum
+grandrapids.museum
+graz.museum
+guernsey.museum
+halloffame.museum
+hamburg.museum
+handson.museum
+harvestcelebration.museum
+hawaii.museum
+health.museum
+heimatunduhren.museum
+hellas.museum
+helsinki.museum
+hembygdsforbund.museum
+heritage.museum
+histoire.museum
+historical.museum
+historicalsociety.museum
+historichouses.museum
+historisch.museum
+historisches.museum
+history.museum
+historyofscience.museum
+horology.museum
+house.museum
+humanities.museum
+illustration.museum
+imageandsound.museum
+indian.museum
+indiana.museum
+indianapolis.museum
+indianmarket.museum
+intelligence.museum
+interactive.museum
+iraq.museum
+iron.museum
+isleofman.museum
+jamison.museum
+jefferson.museum
+jerusalem.museum
+jewelry.museum
+jewish.museum
+jewishart.museum
+jfk.museum
+journalism.museum
+judaica.museum
+judygarland.museum
+juedisches.museum
+juif.museum
+karate.museum
+karikatur.museum
+kids.museum
+koebenhavn.museum
+koeln.museum
+kunst.museum
+kunstsammlung.museum
+kunstunddesign.museum
+labor.museum
+labour.museum
+lajolla.museum
+lancashire.museum
+landes.museum
+lans.museum
+läns.museum
+larsson.museum
+lewismiller.museum
+lincoln.museum
+linz.museum
+living.museum
+livinghistory.museum
+localhistory.museum
+london.museum
+losangeles.museum
+louvre.museum
+loyalist.museum
+lucerne.museum
+luxembourg.museum
+luzern.museum
+mad.museum
+madrid.museum
+mallorca.museum
+manchester.museum
+mansion.museum
+mansions.museum
+manx.museum
+marburg.museum
+maritime.museum
+maritimo.museum
+maryland.museum
+marylhurst.museum
+media.museum
+medical.museum
+medizinhistorisches.museum
+meeres.museum
+memorial.museum
+mesaverde.museum
+michigan.museum
+midatlantic.museum
+military.museum
+mill.museum
+miners.museum
+mining.museum
+minnesota.museum
+missile.museum
+missoula.museum
+modern.museum
+moma.museum
+money.museum
+monmouth.museum
+monticello.museum
+montreal.museum
+moscow.museum
+motorcycle.museum
+muenchen.museum
+muenster.museum
+mulhouse.museum
+muncie.museum
+museet.museum
+museumcenter.museum
+museumvereniging.museum
+music.museum
+national.museum
+nationalfirearms.museum
+nationalheritage.museum
+nativeamerican.museum
+naturalhistory.museum
+naturalhistorymuseum.museum
+naturalsciences.museum
+nature.museum
+naturhistorisches.museum
+natuurwetenschappen.museum
+naumburg.museum
+naval.museum
+nebraska.museum
+neues.museum
+newhampshire.museum
+newjersey.museum
+newmexico.museum
+newport.museum
+newspaper.museum
+newyork.museum
+niepce.museum
+norfolk.museum
+north.museum
+nrw.museum
+nuernberg.museum
+nuremberg.museum
+nyc.museum
+nyny.museum
+oceanographic.museum
+oceanographique.museum
+omaha.museum
+online.museum
+ontario.museum
+openair.museum
+oregon.museum
+oregontrail.museum
+otago.museum
+oxford.museum
+pacific.museum
+paderborn.museum
+palace.museum
+paleo.museum
+palmsprings.museum
+panama.museum
+paris.museum
+pasadena.museum
+pharmacy.museum
+philadelphia.museum
+philadelphiaarea.museum
+philately.museum
+phoenix.museum
+photography.museum
+pilots.museum
+pittsburgh.museum
+planetarium.museum
+plantation.museum
+plants.museum
+plaza.museum
+portal.museum
+portland.museum
+portlligat.museum
+posts-and-telecommunications.museum
+preservation.museum
+presidio.museum
+press.museum
+project.museum
+public.museum
+pubol.museum
+quebec.museum
+railroad.museum
+railway.museum
+research.museum
+resistance.museum
+riodejaneiro.museum
+rochester.museum
+rockart.museum
+roma.museum
+russia.museum
+saintlouis.museum
+salem.museum
+salvadordali.museum
+salzburg.museum
+sandiego.museum
+sanfrancisco.museum
+santabarbara.museum
+santacruz.museum
+santafe.museum
+saskatchewan.museum
+satx.museum
+savannahga.museum
+schlesisches.museum
+schoenbrunn.museum
+schokoladen.museum
+school.museum
+schweiz.museum
+science.museum
+scienceandhistory.museum
+scienceandindustry.museum
+sciencecenter.museum
+sciencecenters.museum
+science-fiction.museum
+sciencehistory.museum
+sciences.museum
+sciencesnaturelles.museum
+scotland.museum
+seaport.museum
+settlement.museum
+settlers.museum
+shell.museum
+sherbrooke.museum
+sibenik.museum
+silk.museum
+ski.museum
+skole.museum
+society.museum
+sologne.museum
+soundandvision.museum
+southcarolina.museum
+southwest.museum
+space.museum
+spy.museum
+square.museum
+stadt.museum
+stalbans.museum
+starnberg.museum
+state.museum
+stateofdelaware.museum
+station.museum
+steam.museum
+steiermark.museum
+stjohn.museum
+stockholm.museum
+stpetersburg.museum
+stuttgart.museum
+suisse.museum
+surgeonshall.museum
+surrey.museum
+svizzera.museum
+sweden.museum
+sydney.museum
+tank.museum
+tcm.museum
+technology.museum
+telekommunikation.museum
+television.museum
+texas.museum
+textile.museum
+theater.museum
+time.museum
+timekeeping.museum
+topology.museum
+torino.museum
+touch.museum
+town.museum
+transport.museum
+tree.museum
+trolley.museum
+trust.museum
+trustee.museum
+uhren.museum
+ulm.museum
+undersea.museum
+university.museum
+usa.museum
+usantiques.museum
+usarts.museum
+uscountryestate.museum
+usculture.museum
+usdecorativearts.museum
+usgarden.museum
+ushistory.museum
+ushuaia.museum
+uslivinghistory.museum
+utah.museum
+uvic.museum
+valley.museum
+vantaa.museum
+versailles.museum
+viking.museum
+village.museum
+virginia.museum
+virtual.museum
+virtuel.museum
+vlaanderen.museum
+volkenkunde.museum
+wales.museum
+wallonie.museum
+war.museum
+washingtondc.museum
+watchandclock.museum
+watch-and-clock.museum
+western.museum
+westfalen.museum
+whaling.museum
+wildlife.museum
+williamsburg.museum
+windmill.museum
+workshop.museum
+york.museum
+yorkshire.museum
+yosemite.museum
+youth.museum
+zoological.museum
+zoology.museum
+ירושלים.museum
+иком.museum
+
+// mv : https://en.wikipedia.org/wiki/.mv
+// "mv" included because, contra Wikipedia, google.mv exists.
+mv
+aero.mv
+biz.mv
+com.mv
+coop.mv
+edu.mv
+gov.mv
+info.mv
+int.mv
+mil.mv
+museum.mv
+name.mv
+net.mv
+org.mv
+pro.mv
+
+// mw : http://www.registrar.mw/
+mw
+ac.mw
+biz.mw
+co.mw
+com.mw
+coop.mw
+edu.mw
+gov.mw
+int.mw
+museum.mw
+net.mw
+org.mw
+
+// mx : http://www.nic.mx/
+// Submitted by registry <farias@nic.mx>
+mx
+com.mx
+org.mx
+gob.mx
+edu.mx
+net.mx
+
+// my : http://www.mynic.net.my/
+my
+com.my
+net.my
+org.my
+gov.my
+edu.my
+mil.my
+name.my
+
+// mz : http://www.uem.mz/
+// Submitted by registry <antonio@uem.mz>
+mz
+ac.mz
+adv.mz
+co.mz
+edu.mz
+gov.mz
+mil.mz
+net.mz
+org.mz
+
+// na : http://www.na-nic.com.na/
+// http://www.info.na/domain/
+na
+info.na
+pro.na
+name.na
+school.na
+or.na
+dr.na
+us.na
+mx.na
+ca.na
+in.na
+cc.na
+tv.na
+ws.na
+mobi.na
+co.na
+com.na
+org.na
+
+// name : has 2nd-level tlds, but there's no list of them
+name
+
+// nc : http://www.cctld.nc/
+nc
+asso.nc
+nom.nc
+
+// ne : https://en.wikipedia.org/wiki/.ne
+ne
+
+// net : https://en.wikipedia.org/wiki/.net
+net
+
+// nf : https://en.wikipedia.org/wiki/.nf
+nf
+com.nf
+net.nf
+per.nf
+rec.nf
+web.nf
+arts.nf
+firm.nf
+info.nf
+other.nf
+store.nf
+
+// ng : http://www.nira.org.ng/index.php/join-us/register-ng-domain/189-nira-slds
+ng
+com.ng
+edu.ng
+gov.ng
+i.ng
+mil.ng
+mobi.ng
+name.ng
+net.ng
+org.ng
+sch.ng
+
+// ni : http://www.nic.ni/
+ni
+ac.ni
+biz.ni
+co.ni
+com.ni
+edu.ni
+gob.ni
+in.ni
+info.ni
+int.ni
+mil.ni
+net.ni
+nom.ni
+org.ni
+web.ni
+
+// nl : https://en.wikipedia.org/wiki/.nl
+//      https://www.sidn.nl/
+//      ccTLD for the Netherlands
+nl
+
+// no : http://www.norid.no/regelverk/index.en.html
+// The Norwegian registry has declined to notify us of updates. The web pages
+// referenced below are the official source of the data. There is also an
+// announce mailing list:
+// https://postlister.uninett.no/sympa/info/norid-diskusjon
+no
+// Norid generic domains : http://www.norid.no/regelverk/vedlegg-c.en.html
+fhs.no
+vgs.no
+fylkesbibl.no
+folkebibl.no
+museum.no
+idrett.no
+priv.no
+// Non-Norid generic domains : http://www.norid.no/regelverk/vedlegg-d.en.html
+mil.no
+stat.no
+dep.no
+kommune.no
+herad.no
+// no geographical names : http://www.norid.no/regelverk/vedlegg-b.en.html
+// counties
+aa.no
+ah.no
+bu.no
+fm.no
+hl.no
+hm.no
+jan-mayen.no
+mr.no
+nl.no
+nt.no
+of.no
+ol.no
+oslo.no
+rl.no
+sf.no
+st.no
+svalbard.no
+tm.no
+tr.no
+va.no
+vf.no
+// primary and lower secondary schools per county
+gs.aa.no
+gs.ah.no
+gs.bu.no
+gs.fm.no
+gs.hl.no
+gs.hm.no
+gs.jan-mayen.no
+gs.mr.no
+gs.nl.no
+gs.nt.no
+gs.of.no
+gs.ol.no
+gs.oslo.no
+gs.rl.no
+gs.sf.no
+gs.st.no
+gs.svalbard.no
+gs.tm.no
+gs.tr.no
+gs.va.no
+gs.vf.no
+// cities
+akrehamn.no
+åkrehamn.no
+algard.no
+ålgård.no
+arna.no
+brumunddal.no
+bryne.no
+bronnoysund.no
+brønnøysund.no
+drobak.no
+drøbak.no
+egersund.no
+fetsund.no
+floro.no
+florø.no
+fredrikstad.no
+hokksund.no
+honefoss.no
+hønefoss.no
+jessheim.no
+jorpeland.no
+jørpeland.no
+kirkenes.no
+kopervik.no
+krokstadelva.no
+langevag.no
+langevåg.no
+leirvik.no
+mjondalen.no
+mjøndalen.no
+mo-i-rana.no
+mosjoen.no
+mosjøen.no
+nesoddtangen.no
+orkanger.no
+osoyro.no
+osøyro.no
+raholt.no
+råholt.no
+sandnessjoen.no
+sandnessjøen.no
+skedsmokorset.no
+slattum.no
+spjelkavik.no
+stathelle.no
+stavern.no
+stjordalshalsen.no
+stjørdalshalsen.no
+tananger.no
+tranby.no
+vossevangen.no
+// communities
+afjord.no
+åfjord.no
+agdenes.no
+al.no
+ål.no
+alesund.no
+ålesund.no
+alstahaug.no
+alta.no
+áltá.no
+alaheadju.no
+álaheadju.no
+alvdal.no
+amli.no
+åmli.no
+amot.no
+åmot.no
+andebu.no
+andoy.no
+andøy.no
+andasuolo.no
+ardal.no
+årdal.no
+aremark.no
+arendal.no
+ås.no
+aseral.no
+åseral.no
+asker.no
+askim.no
+askvoll.no
+askoy.no
+askøy.no
+asnes.no
+åsnes.no
+audnedaln.no
+aukra.no
+aure.no
+aurland.no
+aurskog-holand.no
+aurskog-høland.no
+austevoll.no
+austrheim.no
+averoy.no
+averøy.no
+balestrand.no
+ballangen.no
+balat.no
+bálát.no
+balsfjord.no
+bahccavuotna.no
+báhccavuotna.no
+bamble.no
+bardu.no
+beardu.no
+beiarn.no
+bajddar.no
+bájddar.no
+baidar.no
+báidár.no
+berg.no
+bergen.no
+berlevag.no
+berlevåg.no
+bearalvahki.no
+bearalváhki.no
+bindal.no
+birkenes.no
+bjarkoy.no
+bjarkøy.no
+bjerkreim.no
+bjugn.no
+bodo.no
+bodø.no
+badaddja.no
+bådåddjå.no
+budejju.no
+bokn.no
+bremanger.no
+bronnoy.no
+brønnøy.no
+bygland.no
+bykle.no
+barum.no
+bærum.no
+bo.telemark.no
+bø.telemark.no
+bo.nordland.no
+bø.nordland.no
+bievat.no
+bievát.no
+bomlo.no
+bømlo.no
+batsfjord.no
+båtsfjord.no
+bahcavuotna.no
+báhcavuotna.no
+dovre.no
+drammen.no
+drangedal.no
+dyroy.no
+dyrøy.no
+donna.no
+dønna.no
+eid.no
+eidfjord.no
+eidsberg.no
+eidskog.no
+eidsvoll.no
+eigersund.no
+elverum.no
+enebakk.no
+engerdal.no
+etne.no
+etnedal.no
+evenes.no
+evenassi.no
+evenášši.no
+evje-og-hornnes.no
+farsund.no
+fauske.no
+fuossko.no
+fuoisku.no
+fedje.no
+fet.no
+finnoy.no
+finnøy.no
+fitjar.no
+fjaler.no
+fjell.no
+flakstad.no
+flatanger.no
+flekkefjord.no
+flesberg.no
+flora.no
+fla.no
+flå.no
+folldal.no
+forsand.no
+fosnes.no
+frei.no
+frogn.no
+froland.no
+frosta.no
+frana.no
+fræna.no
+froya.no
+frøya.no
+fusa.no
+fyresdal.no
+forde.no
+førde.no
+gamvik.no
+gangaviika.no
+gáŋgaviika.no
+gaular.no
+gausdal.no
+gildeskal.no
+gildeskål.no
+giske.no
+gjemnes.no
+gjerdrum.no
+gjerstad.no
+gjesdal.no
+gjovik.no
+gjøvik.no
+gloppen.no
+gol.no
+gran.no
+grane.no
+granvin.no
+gratangen.no
+grimstad.no
+grong.no
+kraanghke.no
+kråanghke.no
+grue.no
+gulen.no
+hadsel.no
+halden.no
+halsa.no
+hamar.no
+hamaroy.no
+habmer.no
+hábmer.no
+hapmir.no
+hápmir.no
+hammerfest.no
+hammarfeasta.no
+hámmárfeasta.no
+haram.no
+hareid.no
+harstad.no
+hasvik.no
+aknoluokta.no
+ákŋoluokta.no
+hattfjelldal.no
+aarborte.no
+haugesund.no
+hemne.no
+hemnes.no
+hemsedal.no
+heroy.more-og-romsdal.no
+herøy.møre-og-romsdal.no
+heroy.nordland.no
+herøy.nordland.no
+hitra.no
+hjartdal.no
+hjelmeland.no
+hobol.no
+hobøl.no
+hof.no
+hol.no
+hole.no
+holmestrand.no
+holtalen.no
+holtålen.no
+hornindal.no
+horten.no
+hurdal.no
+hurum.no
+hvaler.no
+hyllestad.no
+hagebostad.no
+hægebostad.no
+hoyanger.no
+høyanger.no
+hoylandet.no
+høylandet.no
+ha.no
+hå.no
+ibestad.no
+inderoy.no
+inderøy.no
+iveland.no
+jevnaker.no
+jondal.no
+jolster.no
+jølster.no
+karasjok.no
+karasjohka.no
+kárášjohka.no
+karlsoy.no
+galsa.no
+gálsá.no
+karmoy.no
+karmøy.no
+kautokeino.no
+guovdageaidnu.no
+klepp.no
+klabu.no
+klæbu.no
+kongsberg.no
+kongsvinger.no
+kragero.no
+kragerø.no
+kristiansand.no
+kristiansund.no
+krodsherad.no
+krødsherad.no
+kvalsund.no
+rahkkeravju.no
+ráhkkerávju.no
+kvam.no
+kvinesdal.no
+kvinnherad.no
+kviteseid.no
+kvitsoy.no
+kvitsøy.no
+kvafjord.no
+kvæfjord.no
+giehtavuoatna.no
+kvanangen.no
+kvænangen.no
+navuotna.no
+návuotna.no
+kafjord.no
+kåfjord.no
+gaivuotna.no
+gáivuotna.no
+larvik.no
+lavangen.no
+lavagis.no
+loabat.no
+loabát.no
+lebesby.no
+davvesiida.no
+leikanger.no
+leirfjord.no
+leka.no
+leksvik.no
+lenvik.no
+leangaviika.no
+leaŋgaviika.no
+lesja.no
+levanger.no
+lier.no
+lierne.no
+lillehammer.no
+lillesand.no
+lindesnes.no
+lindas.no
+lindås.no
+lom.no
+loppa.no
+lahppi.no
+láhppi.no
+lund.no
+lunner.no
+luroy.no
+lurøy.no
+luster.no
+lyngdal.no
+lyngen.no
+ivgu.no
+lardal.no
+lerdal.no
+lærdal.no
+lodingen.no
+lødingen.no
+lorenskog.no
+lørenskog.no
+loten.no
+løten.no
+malvik.no
+masoy.no
+måsøy.no
+muosat.no
+muosát.no
+mandal.no
+marker.no
+marnardal.no
+masfjorden.no
+meland.no
+meldal.no
+melhus.no
+meloy.no
+meløy.no
+meraker.no
+meråker.no
+moareke.no
+moåreke.no
+midsund.no
+midtre-gauldal.no
+modalen.no
+modum.no
+molde.no
+moskenes.no
+moss.no
+mosvik.no
+malselv.no
+målselv.no
+malatvuopmi.no
+málatvuopmi.no
+namdalseid.no
+aejrie.no
+namsos.no
+namsskogan.no
+naamesjevuemie.no
+nååmesjevuemie.no
+laakesvuemie.no
+nannestad.no
+narvik.no
+narviika.no
+naustdal.no
+nedre-eiker.no
+nes.akershus.no
+nes.buskerud.no
+nesna.no
+nesodden.no
+nesseby.no
+unjarga.no
+unjárga.no
+nesset.no
+nissedal.no
+nittedal.no
+nord-aurdal.no
+nord-fron.no
+nord-odal.no
+norddal.no
+nordkapp.no
+davvenjarga.no
+davvenjárga.no
+nordre-land.no
+nordreisa.no
+raisa.no
+ráisa.no
+nore-og-uvdal.no
+notodden.no
+naroy.no
+nærøy.no
+notteroy.no
+nøtterøy.no
+odda.no
+oksnes.no
+øksnes.no
+oppdal.no
+oppegard.no
+oppegård.no
+orkdal.no
+orland.no
+ørland.no
+orskog.no
+ørskog.no
+orsta.no
+ørsta.no
+os.hedmark.no
+os.hordaland.no
+osen.no
+osteroy.no
+osterøy.no
+ostre-toten.no
+østre-toten.no
+overhalla.no
+ovre-eiker.no
+øvre-eiker.no
+oyer.no
+øyer.no
+oygarden.no
+øygarden.no
+oystre-slidre.no
+øystre-slidre.no
+porsanger.no
+porsangu.no
+porsáŋgu.no
+porsgrunn.no
+radoy.no
+radøy.no
+rakkestad.no
+rana.no
+ruovat.no
+randaberg.no
+rauma.no
+rendalen.no
+rennebu.no
+rennesoy.no
+rennesøy.no
+rindal.no
+ringebu.no
+ringerike.no
+ringsaker.no
+rissa.no
+risor.no
+risør.no
+roan.no
+rollag.no
+rygge.no
+ralingen.no
+rælingen.no
+rodoy.no
+rødøy.no
+romskog.no
+rømskog.no
+roros.no
+røros.no
+rost.no
+røst.no
+royken.no
+røyken.no
+royrvik.no
+røyrvik.no
+rade.no
+råde.no
+salangen.no
+siellak.no
+saltdal.no
+salat.no
+sálát.no
+sálat.no
+samnanger.no
+sande.more-og-romsdal.no
+sande.møre-og-romsdal.no
+sande.vestfold.no
+sandefjord.no
+sandnes.no
+sandoy.no
+sandøy.no
+sarpsborg.no
+sauda.no
+sauherad.no
+sel.no
+selbu.no
+selje.no
+seljord.no
+sigdal.no
+siljan.no
+sirdal.no
+skaun.no
+skedsmo.no
+ski.no
+skien.no
+skiptvet.no
+skjervoy.no
+skjervøy.no
+skierva.no
+skiervá.no
+skjak.no
+skjåk.no
+skodje.no
+skanland.no
+skånland.no
+skanit.no
+skánit.no
+smola.no
+smøla.no
+snillfjord.no
+snasa.no
+snåsa.no
+snoasa.no
+snaase.no
+snåase.no
+sogndal.no
+sokndal.no
+sola.no
+solund.no
+songdalen.no
+sortland.no
+spydeberg.no
+stange.no
+stavanger.no
+steigen.no
+steinkjer.no
+stjordal.no
+stjørdal.no
+stokke.no
+stor-elvdal.no
+stord.no
+stordal.no
+storfjord.no
+omasvuotna.no
+strand.no
+stranda.no
+stryn.no
+sula.no
+suldal.no
+sund.no
+sunndal.no
+surnadal.no
+sveio.no
+svelvik.no
+sykkylven.no
+sogne.no
+søgne.no
+somna.no
+sømna.no
+sondre-land.no
+søndre-land.no
+sor-aurdal.no
+sør-aurdal.no
+sor-fron.no
+sør-fron.no
+sor-odal.no
+sør-odal.no
+sor-varanger.no
+sør-varanger.no
+matta-varjjat.no
+mátta-várjjat.no
+sorfold.no
+sørfold.no
+sorreisa.no
+sørreisa.no
+sorum.no
+sørum.no
+tana.no
+deatnu.no
+time.no
+tingvoll.no
+tinn.no
+tjeldsund.no
+dielddanuorri.no
+tjome.no
+tjøme.no
+tokke.no
+tolga.no
+torsken.no
+tranoy.no
+tranøy.no
+tromso.no
+tromsø.no
+tromsa.no
+romsa.no
+trondheim.no
+troandin.no
+trysil.no
+trana.no
+træna.no
+trogstad.no
+trøgstad.no
+tvedestrand.no
+tydal.no
+tynset.no
+tysfjord.no
+divtasvuodna.no
+divttasvuotna.no
+tysnes.no
+tysvar.no
+tysvær.no
+tonsberg.no
+tønsberg.no
+ullensaker.no
+ullensvang.no
+ulvik.no
+utsira.no
+vadso.no
+vadsø.no
+cahcesuolo.no
+čáhcesuolo.no
+vaksdal.no
+valle.no
+vang.no
+vanylven.no
+vardo.no
+vardø.no
+varggat.no
+várggát.no
+vefsn.no
+vaapste.no
+vega.no
+vegarshei.no
+vegårshei.no
+vennesla.no
+verdal.no
+verran.no
+vestby.no
+vestnes.no
+vestre-slidre.no
+vestre-toten.no
+vestvagoy.no
+vestvågøy.no
+vevelstad.no
+vik.no
+vikna.no
+vindafjord.no
+volda.no
+voss.no
+varoy.no
+værøy.no
+vagan.no
+vågan.no
+voagat.no
+vagsoy.no
+vågsøy.no
+vaga.no
+vågå.no
+valer.ostfold.no
+våler.østfold.no
+valer.hedmark.no
+våler.hedmark.no
+
+// np : http://www.mos.com.np/register.html
+*.np
+
+// nr : http://cenpac.net.nr/dns/index.html
+// Submitted by registry <technician@cenpac.net.nr>
+nr
+biz.nr
+info.nr
+gov.nr
+edu.nr
+org.nr
+net.nr
+com.nr
+
+// nu : https://en.wikipedia.org/wiki/.nu
+nu
+
+// nz : https://en.wikipedia.org/wiki/.nz
+// Submitted by registry <jay@nzrs.net.nz>
+nz
+ac.nz
+co.nz
+cri.nz
+geek.nz
+gen.nz
+govt.nz
+health.nz
+iwi.nz
+kiwi.nz
+maori.nz
+mil.nz
+māori.nz
+net.nz
+org.nz
+parliament.nz
+school.nz
+
+// om : https://en.wikipedia.org/wiki/.om
+om
+co.om
+com.om
+edu.om
+gov.om
+med.om
+museum.om
+net.om
+org.om
+pro.om
+
+// onion : https://tools.ietf.org/html/rfc7686
+onion
+
+// org : https://en.wikipedia.org/wiki/.org
+org
+
+// pa : http://www.nic.pa/
+// Some additional second level "domains" resolve directly as hostnames, such as
+// pannet.pa, so we add a rule for "pa".
+pa
+ac.pa
+gob.pa
+com.pa
+org.pa
+sld.pa
+edu.pa
+net.pa
+ing.pa
+abo.pa
+med.pa
+nom.pa
+
+// pe : https://www.nic.pe/InformeFinalComision.pdf
+pe
+edu.pe
+gob.pe
+nom.pe
+mil.pe
+org.pe
+com.pe
+net.pe
+
+// pf : http://www.gobin.info/domainname/formulaire-pf.pdf
+pf
+com.pf
+org.pf
+edu.pf
+
+// pg : https://en.wikipedia.org/wiki/.pg
+*.pg
+
+// ph : http://www.domains.ph/FAQ2.asp
+// Submitted by registry <jed@email.com.ph>
+ph
+com.ph
+net.ph
+org.ph
+gov.ph
+edu.ph
+ngo.ph
+mil.ph
+i.ph
+
+// pk : http://pk5.pknic.net.pk/pk5/msgNamepk.PK
+pk
+com.pk
+net.pk
+edu.pk
+org.pk
+fam.pk
+biz.pk
+web.pk
+gov.pk
+gob.pk
+gok.pk
+gon.pk
+gop.pk
+gos.pk
+info.pk
+
+// pl http://www.dns.pl/english/index.html
+// Submitted by registry
+pl
+com.pl
+net.pl
+org.pl
+// pl functional domains (http://www.dns.pl/english/index.html)
+aid.pl
+agro.pl
+atm.pl
+auto.pl
+biz.pl
+edu.pl
+gmina.pl
+gsm.pl
+info.pl
+mail.pl
+miasta.pl
+media.pl
+mil.pl
+nieruchomosci.pl
+nom.pl
+pc.pl
+powiat.pl
+priv.pl
+realestate.pl
+rel.pl
+sex.pl
+shop.pl
+sklep.pl
+sos.pl
+szkola.pl
+targi.pl
+tm.pl
+tourism.pl
+travel.pl
+turystyka.pl
+// Government domains
+gov.pl
+ap.gov.pl
+ic.gov.pl
+is.gov.pl
+us.gov.pl
+kmpsp.gov.pl
+kppsp.gov.pl
+kwpsp.gov.pl
+psp.gov.pl
+wskr.gov.pl
+kwp.gov.pl
+mw.gov.pl
+ug.gov.pl
+um.gov.pl
+umig.gov.pl
+ugim.gov.pl
+upow.gov.pl
+uw.gov.pl
+starostwo.gov.pl
+pa.gov.pl
+po.gov.pl
+psse.gov.pl
+pup.gov.pl
+rzgw.gov.pl
+sa.gov.pl
+so.gov.pl
+sr.gov.pl
+wsa.gov.pl
+sko.gov.pl
+uzs.gov.pl
+wiih.gov.pl
+winb.gov.pl
+pinb.gov.pl
+wios.gov.pl
+witd.gov.pl
+wzmiuw.gov.pl
+piw.gov.pl
+wiw.gov.pl
+griw.gov.pl
+wif.gov.pl
+oum.gov.pl
+sdn.gov.pl
+zp.gov.pl
+uppo.gov.pl
+mup.gov.pl
+wuoz.gov.pl
+konsulat.gov.pl
+oirm.gov.pl
+// pl regional domains (http://www.dns.pl/english/index.html)
+augustow.pl
+babia-gora.pl
+bedzin.pl
+beskidy.pl
+bialowieza.pl
+bialystok.pl
+bielawa.pl
+bieszczady.pl
+boleslawiec.pl
+bydgoszcz.pl
+bytom.pl
+cieszyn.pl
+czeladz.pl
+czest.pl
+dlugoleka.pl
+elblag.pl
+elk.pl
+glogow.pl
+gniezno.pl
+gorlice.pl
+grajewo.pl
+ilawa.pl
+jaworzno.pl
+jelenia-gora.pl
+jgora.pl
+kalisz.pl
+kazimierz-dolny.pl
+karpacz.pl
+kartuzy.pl
+kaszuby.pl
+katowice.pl
+kepno.pl
+ketrzyn.pl
+klodzko.pl
+kobierzyce.pl
+kolobrzeg.pl
+konin.pl
+konskowola.pl
+kutno.pl
+lapy.pl
+lebork.pl
+legnica.pl
+lezajsk.pl
+limanowa.pl
+lomza.pl
+lowicz.pl
+lubin.pl
+lukow.pl
+malbork.pl
+malopolska.pl
+mazowsze.pl
+mazury.pl
+mielec.pl
+mielno.pl
+mragowo.pl
+naklo.pl
+nowaruda.pl
+nysa.pl
+olawa.pl
+olecko.pl
+olkusz.pl
+olsztyn.pl
+opoczno.pl
+opole.pl
+ostroda.pl
+ostroleka.pl
+ostrowiec.pl
+ostrowwlkp.pl
+pila.pl
+pisz.pl
+podhale.pl
+podlasie.pl
+polkowice.pl
+pomorze.pl
+pomorskie.pl
+prochowice.pl
+pruszkow.pl
+przeworsk.pl
+pulawy.pl
+radom.pl
+rawa-maz.pl
+rybnik.pl
+rzeszow.pl
+sanok.pl
+sejny.pl
+slask.pl
+slupsk.pl
+sosnowiec.pl
+stalowa-wola.pl
+skoczow.pl
+starachowice.pl
+stargard.pl
+suwalki.pl
+swidnica.pl
+swiebodzin.pl
+swinoujscie.pl
+szczecin.pl
+szczytno.pl
+tarnobrzeg.pl
+tgory.pl
+turek.pl
+tychy.pl
+ustka.pl
+walbrzych.pl
+warmia.pl
+warszawa.pl
+waw.pl
+wegrow.pl
+wielun.pl
+wlocl.pl
+wloclawek.pl
+wodzislaw.pl
+wolomin.pl
+wroclaw.pl
+zachpomor.pl
+zagan.pl
+zarow.pl
+zgora.pl
+zgorzelec.pl
+
+// pm : http://www.afnic.fr/medias/documents/AFNIC-naming-policy2012.pdf
+pm
+
+// pn : http://www.government.pn/PnRegistry/policies.htm
+pn
+gov.pn
+co.pn
+org.pn
+edu.pn
+net.pn
+
+// post : https://en.wikipedia.org/wiki/.post
+post
+
+// pr : http://www.nic.pr/index.asp?f=1
+pr
+com.pr
+net.pr
+org.pr
+gov.pr
+edu.pr
+isla.pr
+pro.pr
+biz.pr
+info.pr
+name.pr
+// these aren't mentioned on nic.pr, but on https://en.wikipedia.org/wiki/.pr
+est.pr
+prof.pr
+ac.pr
+
+// pro : http://registry.pro/get-pro
+pro
+aaa.pro
+aca.pro
+acct.pro
+avocat.pro
+bar.pro
+cpa.pro
+eng.pro
+jur.pro
+law.pro
+med.pro
+recht.pro
+
+// ps : https://en.wikipedia.org/wiki/.ps
+// http://www.nic.ps/registration/policy.html#reg
+ps
+edu.ps
+gov.ps
+sec.ps
+plo.ps
+com.ps
+org.ps
+net.ps
+
+// pt : http://online.dns.pt/dns/start_dns
+pt
+net.pt
+gov.pt
+org.pt
+edu.pt
+int.pt
+publ.pt
+com.pt
+nome.pt
+
+// pw : https://en.wikipedia.org/wiki/.pw
+pw
+co.pw
+ne.pw
+or.pw
+ed.pw
+go.pw
+belau.pw
+
+// py : http://www.nic.py/pautas.html#seccion_9
+// Submitted by registry
+py
+com.py
+coop.py
+edu.py
+gov.py
+mil.py
+net.py
+org.py
+
+// qa : http://domains.qa/en/
+qa
+com.qa
+edu.qa
+gov.qa
+mil.qa
+name.qa
+net.qa
+org.qa
+sch.qa
+
+// re : http://www.afnic.re/obtenir/chartes/nommage-re/annexe-descriptifs
+re
+asso.re
+com.re
+nom.re
+
+// ro : http://www.rotld.ro/
+ro
+arts.ro
+com.ro
+firm.ro
+info.ro
+nom.ro
+nt.ro
+org.ro
+rec.ro
+store.ro
+tm.ro
+www.ro
+
+// rs : https://www.rnids.rs/en/domains/national-domains
+rs
+ac.rs
+co.rs
+edu.rs
+gov.rs
+in.rs
+org.rs
+
+// ru : https://cctld.ru/en/domains/domens_ru/reserved/
+ru
+ac.ru
+edu.ru
+gov.ru
+int.ru
+mil.ru
+test.ru
+
+// rw : http://www.nic.rw/cgi-bin/policy.pl
+rw
+gov.rw
+net.rw
+edu.rw
+ac.rw
+com.rw
+co.rw
+int.rw
+mil.rw
+gouv.rw
+
+// sa : http://www.nic.net.sa/
+sa
+com.sa
+net.sa
+org.sa
+gov.sa
+med.sa
+pub.sa
+edu.sa
+sch.sa
+
+// sb : http://www.sbnic.net.sb/
+// Submitted by registry <lee.humphries@telekom.com.sb>
+sb
+com.sb
+edu.sb
+gov.sb
+net.sb
+org.sb
+
+// sc : http://www.nic.sc/
+sc
+com.sc
+gov.sc
+net.sc
+org.sc
+edu.sc
+
+// sd : http://www.isoc.sd/sudanic.isoc.sd/billing_pricing.htm
+// Submitted by registry <admin@isoc.sd>
+sd
+com.sd
+net.sd
+org.sd
+edu.sd
+med.sd
+tv.sd
+gov.sd
+info.sd
+
+// se : https://en.wikipedia.org/wiki/.se
+// Submitted by registry <patrik.wallstrom@iis.se>
+se
+a.se
+ac.se
+b.se
+bd.se
+brand.se
+c.se
+d.se
+e.se
+f.se
+fh.se
+fhsk.se
+fhv.se
+g.se
+h.se
+i.se
+k.se
+komforb.se
+kommunalforbund.se
+komvux.se
+l.se
+lanbib.se
+m.se
+n.se
+naturbruksgymn.se
+o.se
+org.se
+p.se
+parti.se
+pp.se
+press.se
+r.se
+s.se
+t.se
+tm.se
+u.se
+w.se
+x.se
+y.se
+z.se
+
+// sg : http://www.nic.net.sg/page/registration-policies-procedures-and-guidelines
+sg
+com.sg
+net.sg
+org.sg
+gov.sg
+edu.sg
+per.sg
+
+// sh : http://www.nic.sh/registrar.html
+sh
+com.sh
+net.sh
+gov.sh
+org.sh
+mil.sh
+
+// si : https://en.wikipedia.org/wiki/.si
+si
+
+// sj : No registrations at this time.
+// Submitted by registry <jarle@uninett.no>
+sj
+
+// sk : https://en.wikipedia.org/wiki/.sk
+// list of 2nd level domains ?
+sk
+
+// sl : http://www.nic.sl
+// Submitted by registry <adam@neoip.com>
+sl
+com.sl
+net.sl
+edu.sl
+gov.sl
+org.sl
+
+// sm : https://en.wikipedia.org/wiki/.sm
+sm
+
+// sn : https://en.wikipedia.org/wiki/.sn
+sn
+art.sn
+com.sn
+edu.sn
+gouv.sn
+org.sn
+perso.sn
+univ.sn
+
+// so : http://www.soregistry.com/
+so
+com.so
+net.so
+org.so
+
+// sr : https://en.wikipedia.org/wiki/.sr
+sr
+
+// st : http://www.nic.st/html/policyrules/
+st
+co.st
+com.st
+consulado.st
+edu.st
+embaixada.st
+gov.st
+mil.st
+net.st
+org.st
+principe.st
+saotome.st
+store.st
+
+// su : https://en.wikipedia.org/wiki/.su
+su
+
+// sv : http://www.svnet.org.sv/niveldos.pdf
+sv
+com.sv
+edu.sv
+gob.sv
+org.sv
+red.sv
+
+// sx : https://en.wikipedia.org/wiki/.sx
+// Submitted by registry <jcvignes@openregistry.com>
+sx
+gov.sx
+
+// sy : https://en.wikipedia.org/wiki/.sy
+// see also: http://www.gobin.info/domainname/sy.doc
+sy
+edu.sy
+gov.sy
+net.sy
+mil.sy
+com.sy
+org.sy
+
+// sz : https://en.wikipedia.org/wiki/.sz
+// http://www.sispa.org.sz/
+sz
+co.sz
+ac.sz
+org.sz
+
+// tc : https://en.wikipedia.org/wiki/.tc
+tc
+
+// td : https://en.wikipedia.org/wiki/.td
+td
+
+// tel: https://en.wikipedia.org/wiki/.tel
+// http://www.telnic.org/
+tel
+
+// tf : https://en.wikipedia.org/wiki/.tf
+tf
+
+// tg : https://en.wikipedia.org/wiki/.tg
+// http://www.nic.tg/
+tg
+
+// th : https://en.wikipedia.org/wiki/.th
+// Submitted by registry <krit@thains.co.th>
+th
+ac.th
+co.th
+go.th
+in.th
+mi.th
+net.th
+or.th
+
+// tj : http://www.nic.tj/policy.html
+tj
+ac.tj
+biz.tj
+co.tj
+com.tj
+edu.tj
+go.tj
+gov.tj
+int.tj
+mil.tj
+name.tj
+net.tj
+nic.tj
+org.tj
+test.tj
+web.tj
+
+// tk : https://en.wikipedia.org/wiki/.tk
+tk
+
+// tl : https://en.wikipedia.org/wiki/.tl
+tl
+gov.tl
+
+// tm : http://www.nic.tm/local.html
+tm
+com.tm
+co.tm
+org.tm
+net.tm
+nom.tm
+gov.tm
+mil.tm
+edu.tm
+
+// tn : https://en.wikipedia.org/wiki/.tn
+// http://whois.ati.tn/
+tn
+com.tn
+ens.tn
+fin.tn
+gov.tn
+ind.tn
+intl.tn
+nat.tn
+net.tn
+org.tn
+info.tn
+perso.tn
+tourism.tn
+edunet.tn
+rnrt.tn
+rns.tn
+rnu.tn
+mincom.tn
+agrinet.tn
+defense.tn
+turen.tn
+
+// to : https://en.wikipedia.org/wiki/.to
+// Submitted by registry <egullich@colo.to>
+to
+com.to
+gov.to
+net.to
+org.to
+edu.to
+mil.to
+
+// subTLDs: https://www.nic.tr/forms/eng/policies.pdf
+//     and: https://www.nic.tr/forms/politikalar.pdf
+// Submitted by <mehmetgurevin@gmail.com>
+tr
+com.tr
+info.tr
+biz.tr
+net.tr
+org.tr
+web.tr
+gen.tr
+tv.tr
+av.tr
+dr.tr
+bbs.tr
+name.tr
+tel.tr
+gov.tr
+bel.tr
+pol.tr
+mil.tr
+k12.tr
+edu.tr
+kep.tr
+
+// Used by Northern Cyprus
+nc.tr
+
+// Used by government agencies of Northern Cyprus
+gov.nc.tr
+
+// tt : http://www.nic.tt/
+tt
+co.tt
+com.tt
+org.tt
+net.tt
+biz.tt
+info.tt
+pro.tt
+int.tt
+coop.tt
+jobs.tt
+mobi.tt
+travel.tt
+museum.tt
+aero.tt
+name.tt
+gov.tt
+edu.tt
+
+// tv : https://en.wikipedia.org/wiki/.tv
+// Not listing any 2LDs as reserved since none seem to exist in practice,
+// Wikipedia notwithstanding.
+tv
+
+// tw : https://en.wikipedia.org/wiki/.tw
+tw
+edu.tw
+gov.tw
+mil.tw
+com.tw
+net.tw
+org.tw
+idv.tw
+game.tw
+ebiz.tw
+club.tw
+網路.tw
+組織.tw
+商業.tw
+
+// tz : http://www.tznic.or.tz/index.php/domains
+// Submitted by registry <manager@tznic.or.tz>
+tz
+ac.tz
+co.tz
+go.tz
+hotel.tz
+info.tz
+me.tz
+mil.tz
+mobi.tz
+ne.tz
+or.tz
+sc.tz
+tv.tz
+
+// ua : https://hostmaster.ua/policy/?ua
+// Submitted by registry <dk@cctld.ua>
+ua
+// ua 2LD
+com.ua
+edu.ua
+gov.ua
+in.ua
+net.ua
+org.ua
+// ua geographic names
+// https://hostmaster.ua/2ld/
+cherkassy.ua
+cherkasy.ua
+chernigov.ua
+chernihiv.ua
+chernivtsi.ua
+chernovtsy.ua
+ck.ua
+cn.ua
+cr.ua
+crimea.ua
+cv.ua
+dn.ua
+dnepropetrovsk.ua
+dnipropetrovsk.ua
+dominic.ua
+donetsk.ua
+dp.ua
+if.ua
+ivano-frankivsk.ua
+kh.ua
+kharkiv.ua
+kharkov.ua
+kherson.ua
+khmelnitskiy.ua
+khmelnytskyi.ua
+kiev.ua
+kirovograd.ua
+km.ua
+kr.ua
+krym.ua
+ks.ua
+kv.ua
+kyiv.ua
+lg.ua
+lt.ua
+lugansk.ua
+lutsk.ua
+lv.ua
+lviv.ua
+mk.ua
+mykolaiv.ua
+nikolaev.ua
+od.ua
+odesa.ua
+odessa.ua
+pl.ua
+poltava.ua
+rivne.ua
+rovno.ua
+rv.ua
+sb.ua
+sebastopol.ua
+sevastopol.ua
+sm.ua
+sumy.ua
+te.ua
+ternopil.ua
+uz.ua
+uzhgorod.ua
+vinnica.ua
+vinnytsia.ua
+vn.ua
+volyn.ua
+yalta.ua
+zaporizhzhe.ua
+zaporizhzhia.ua
+zhitomir.ua
+zhytomyr.ua
+zp.ua
+zt.ua
+
+// ug : https://www.registry.co.ug/
+ug
+co.ug
+or.ug
+ac.ug
+sc.ug
+go.ug
+ne.ug
+com.ug
+org.ug
+
+// uk : https://en.wikipedia.org/wiki/.uk
+// Submitted by registry <Michael.Daly@nominet.org.uk>
+uk
+ac.uk
+co.uk
+gov.uk
+ltd.uk
+me.uk
+net.uk
+nhs.uk
+org.uk
+plc.uk
+police.uk
+*.sch.uk
+
+// us : https://en.wikipedia.org/wiki/.us
+us
+dni.us
+fed.us
+isa.us
+kids.us
+nsn.us
+// us geographic names
+ak.us
+al.us
+ar.us
+as.us
+az.us
+ca.us
+co.us
+ct.us
+dc.us
+de.us
+fl.us
+ga.us
+gu.us
+hi.us
+ia.us
+id.us
+il.us
+in.us
+ks.us
+ky.us
+la.us
+ma.us
+md.us
+me.us
+mi.us
+mn.us
+mo.us
+ms.us
+mt.us
+nc.us
+nd.us
+ne.us
+nh.us
+nj.us
+nm.us
+nv.us
+ny.us
+oh.us
+ok.us
+or.us
+pa.us
+pr.us
+ri.us
+sc.us
+sd.us
+tn.us
+tx.us
+ut.us
+vi.us
+vt.us
+va.us
+wa.us
+wi.us
+wv.us
+wy.us
+// The registrar notes several more specific domains available in each state,
+// such as state.*.us, dst.*.us, etc., but resolution of these is somewhat
+// haphazard; in some states these domains resolve as addresses, while in others
+// only subdomains are available, or even nothing at all. We include the
+// most common ones where it's clear that different sites are different
+// entities.
+k12.ak.us
+k12.al.us
+k12.ar.us
+k12.as.us
+k12.az.us
+k12.ca.us
+k12.co.us
+k12.ct.us
+k12.dc.us
+k12.de.us
+k12.fl.us
+k12.ga.us
+k12.gu.us
+// k12.hi.us  Bug 614565 - Hawaii has a state-wide DOE login
+k12.ia.us
+k12.id.us
+k12.il.us
+k12.in.us
+k12.ks.us
+k12.ky.us
+k12.la.us
+k12.ma.us
+k12.md.us
+k12.me.us
+k12.mi.us
+k12.mn.us
+k12.mo.us
+k12.ms.us
+k12.mt.us
+k12.nc.us
+// k12.nd.us  Bug 1028347 - Removed at request of Travis Rosso <trossow@nd.gov>
+k12.ne.us
+k12.nh.us
+k12.nj.us
+k12.nm.us
+k12.nv.us
+k12.ny.us
+k12.oh.us
+k12.ok.us
+k12.or.us
+k12.pa.us
+k12.pr.us
+k12.ri.us
+k12.sc.us
+// k12.sd.us  Bug 934131 - Removed at request of James Booze <James.Booze@k12.sd.us>
+k12.tn.us
+k12.tx.us
+k12.ut.us
+k12.vi.us
+k12.vt.us
+k12.va.us
+k12.wa.us
+k12.wi.us
+// k12.wv.us  Bug 947705 - Removed at request of Verne Britton <verne@wvnet.edu>
+k12.wy.us
+cc.ak.us
+cc.al.us
+cc.ar.us
+cc.as.us
+cc.az.us
+cc.ca.us
+cc.co.us
+cc.ct.us
+cc.dc.us
+cc.de.us
+cc.fl.us
+cc.ga.us
+cc.gu.us
+cc.hi.us
+cc.ia.us
+cc.id.us
+cc.il.us
+cc.in.us
+cc.ks.us
+cc.ky.us
+cc.la.us
+cc.ma.us
+cc.md.us
+cc.me.us
+cc.mi.us
+cc.mn.us
+cc.mo.us
+cc.ms.us
+cc.mt.us
+cc.nc.us
+cc.nd.us
+cc.ne.us
+cc.nh.us
+cc.nj.us
+cc.nm.us
+cc.nv.us
+cc.ny.us
+cc.oh.us
+cc.ok.us
+cc.or.us
+cc.pa.us
+cc.pr.us
+cc.ri.us
+cc.sc.us
+cc.sd.us
+cc.tn.us
+cc.tx.us
+cc.ut.us
+cc.vi.us
+cc.vt.us
+cc.va.us
+cc.wa.us
+cc.wi.us
+cc.wv.us
+cc.wy.us
+lib.ak.us
+lib.al.us
+lib.ar.us
+lib.as.us
+lib.az.us
+lib.ca.us
+lib.co.us
+lib.ct.us
+lib.dc.us
+// lib.de.us  Issue #243 - Moved to Private section at request of Ed Moore <Ed.Moore@lib.de.us>
+lib.fl.us
+lib.ga.us
+lib.gu.us
+lib.hi.us
+lib.ia.us
+lib.id.us
+lib.il.us
+lib.in.us
+lib.ks.us
+lib.ky.us
+lib.la.us
+lib.ma.us
+lib.md.us
+lib.me.us
+lib.mi.us
+lib.mn.us
+lib.mo.us
+lib.ms.us
+lib.mt.us
+lib.nc.us
+lib.nd.us
+lib.ne.us
+lib.nh.us
+lib.nj.us
+lib.nm.us
+lib.nv.us
+lib.ny.us
+lib.oh.us
+lib.ok.us
+lib.or.us
+lib.pa.us
+lib.pr.us
+lib.ri.us
+lib.sc.us
+lib.sd.us
+lib.tn.us
+lib.tx.us
+lib.ut.us
+lib.vi.us
+lib.vt.us
+lib.va.us
+lib.wa.us
+lib.wi.us
+// lib.wv.us  Bug 941670 - Removed at request of Larry W Arnold <arnold@wvlc.lib.wv.us>
+lib.wy.us
+// k12.ma.us contains school districts in Massachusetts. The 4LDs are
+//  managed independently except for private (PVT), charter (CHTR) and
+//  parochial (PAROCH) schools.  Those are delegated directly to the
+//  5LD operators.   <k12-ma-hostmaster _ at _ rsuc.gweep.net>
+pvt.k12.ma.us
+chtr.k12.ma.us
+paroch.k12.ma.us
+// Merit Network, Inc. maintains the registry for =~ /(k12|cc|lib).mi.us/ and the following
+//    see also: http://domreg.merit.edu
+//    see also: whois -h whois.domreg.merit.edu help
+ann-arbor.mi.us
+cog.mi.us
+dst.mi.us
+eaton.mi.us
+gen.mi.us
+mus.mi.us
+tec.mi.us
+washtenaw.mi.us
+
+// uy : http://www.nic.org.uy/
+uy
+com.uy
+edu.uy
+gub.uy
+mil.uy
+net.uy
+org.uy
+
+// uz : http://www.reg.uz/
+uz
+co.uz
+com.uz
+net.uz
+org.uz
+
+// va : https://en.wikipedia.org/wiki/.va
+va
+
+// vc : https://en.wikipedia.org/wiki/.vc
+// Submitted by registry <kshah@ca.afilias.info>
+vc
+com.vc
+net.vc
+org.vc
+gov.vc
+mil.vc
+edu.vc
+
+// ve : https://registro.nic.ve/
+// Submitted by registry
+ve
+arts.ve
+co.ve
+com.ve
+e12.ve
+edu.ve
+firm.ve
+gob.ve
+gov.ve
+info.ve
+int.ve
+mil.ve
+net.ve
+org.ve
+rec.ve
+store.ve
+tec.ve
+web.ve
+
+// vg : https://en.wikipedia.org/wiki/.vg
+vg
+
+// vi : http://www.nic.vi/newdomainform.htm
+// http://www.nic.vi/Domain_Rules/body_domain_rules.html indicates some other
+// TLDs are "reserved", such as edu.vi and gov.vi, but doesn't actually say they
+// are available for registration (which they do not seem to be).
+vi
+co.vi
+com.vi
+k12.vi
+net.vi
+org.vi
+
+// vn : https://www.dot.vn/vnnic/vnnic/domainregistration.jsp
+vn
+com.vn
+net.vn
+org.vn
+edu.vn
+gov.vn
+int.vn
+ac.vn
+biz.vn
+info.vn
+name.vn
+pro.vn
+health.vn
+
+// vu : https://en.wikipedia.org/wiki/.vu
+// http://www.vunic.vu/
+vu
+com.vu
+edu.vu
+net.vu
+org.vu
+
+// wf : http://www.afnic.fr/medias/documents/AFNIC-naming-policy2012.pdf
+wf
+
+// ws : https://en.wikipedia.org/wiki/.ws
+// http://samoanic.ws/index.dhtml
+ws
+com.ws
+net.ws
+org.ws
+gov.ws
+edu.ws
+
+// yt : http://www.afnic.fr/medias/documents/AFNIC-naming-policy2012.pdf
+yt
+
+// IDN ccTLDs
+// When submitting patches, please maintain a sort by ISO 3166 ccTLD, then
+// U-label, and follow this format:
+// // A-Label ("<Latin renderings>", <language name>[, variant info]) : <ISO 3166 ccTLD>
+// // [sponsoring org]
+// U-Label
+
+// xn--mgbaam7a8h ("Emerat", Arabic) : AE
+// http://nic.ae/english/arabicdomain/rules.jsp
+امارات
+
+// xn--y9a3aq ("hye", Armenian) : AM
+// ISOC AM (operated by .am Registry)
+հայ
+
+// xn--54b7fta0cc ("Bangla", Bangla) : BD
+বাংলা
+
+// xn--90ae ("bg", Bulgarian) : BG
+бг
+
+// xn--90ais ("bel", Belarusian/Russian Cyrillic) : BY
+// Operated by .by registry
+бел
+
+// xn--fiqs8s ("Zhongguo/China", Chinese, Simplified) : CN
+// CNNIC
+// http://cnnic.cn/html/Dir/2005/10/11/3218.htm
+中国
+
+// xn--fiqz9s ("Zhongguo/China", Chinese, Traditional) : CN
+// CNNIC
+// http://cnnic.cn/html/Dir/2005/10/11/3218.htm
+中國
+
+// xn--lgbbat1ad8j ("Algeria/Al Jazair", Arabic) : DZ
+الجزائر
+
+// xn--wgbh1c ("Egypt/Masr", Arabic) : EG
+// http://www.dotmasr.eg/
+مصر
+
+// xn--e1a4c ("eu", Cyrillic) : EU
+ею
+
+// xn--node ("ge", Georgian Mkhedruli) : GE
+გე
+
+// xn--qxam ("el", Greek) : GR
+// Hellenic Ministry of Infrastructure, Transport, and Networks
+ελ
+
+// xn--j6w193g ("Hong Kong", Chinese) : HK
+// https://www.hkirc.hk
+// Submitted by registry <hk.tech@hkirc.hk>
+// https://www.hkirc.hk/content.jsp?id=30#!/34
+香港
+公司.香港
+教育.香港
+政府.香港
+個人.香港
+網絡.香港
+組織.香港
+
+// xn--2scrj9c ("Bharat", Kannada) : IN
+// India
+ಭಾರತ
+
+// xn--3hcrj9c ("Bharat", Oriya) : IN
+// India
+ଭାରତ
+
+// xn--45br5cyl ("Bharatam", Assamese) : IN
+// India
+ভাৰত
+
+// xn--h2breg3eve ("Bharatam", Sanskrit) : IN
+// India
+भारतम्
+
+// xn--h2brj9c8c ("Bharot", Santali) : IN
+// India
+भारोत
+
+// xn--mgbgu82a ("Bharat", Sindhi) : IN
+// India
+ڀارت
+
+// xn--rvc1e0am3e ("Bharatam", Malayalam) : IN
+// India
+ഭാരതം
+
+// xn--h2brj9c ("Bharat", Devanagari) : IN
+// India
+भारत
+
+// xn--mgbbh1a ("Bharat", Kashmiri) : IN
+// India
+بارت
+
+// xn--mgbbh1a71e ("Bharat", Arabic) : IN
+// India
+بھارت
+
+// xn--fpcrj9c3d ("Bharat", Telugu) : IN
+// India
+భారత్
+
+// xn--gecrj9c ("Bharat", Gujarati) : IN
+// India
+ભારત
+
+// xn--s9brj9c ("Bharat", Gurmukhi) : IN
+// India
+ਭਾਰਤ
+
+// xn--45brj9c ("Bharat", Bengali) : IN
+// India
+ভারত
+
+// xn--xkc2dl3a5ee0h ("India", Tamil) : IN
+// India
+இந்தியா
+
+// xn--mgba3a4f16a ("Iran", Persian) : IR
+ایران
+
+// xn--mgba3a4fra ("Iran", Arabic) : IR
+ايران
+
+// xn--mgbtx2b ("Iraq", Arabic) : IQ
+// Communications and Media Commission
+عراق
+
+// xn--mgbayh7gpa ("al-Ordon", Arabic) : JO
+// National Information Technology Center (NITC)
+// Royal Scientific Society, Al-Jubeiha
+الاردن
+
+// xn--3e0b707e ("Republic of Korea", Hangul) : KR
+한국
+
+// xn--80ao21a ("Kaz", Kazakh) : KZ
+қаз
+
+// xn--fzc2c9e2c ("Lanka", Sinhalese-Sinhala) : LK
+// http://nic.lk
+ලංකා
+
+// xn--xkc2al3hye2a ("Ilangai", Tamil) : LK
+// http://nic.lk
+இலங்கை
+
+// xn--mgbc0a9azcg ("Morocco/al-Maghrib", Arabic) : MA
+المغرب
+
+// xn--d1alf ("mkd", Macedonian) : MK
+// MARnet
+мкд
+
+// xn--l1acc ("mon", Mongolian) : MN
+мон
+
+// xn--mix891f ("Macao", Chinese, Traditional) : MO
+// MONIC / HNET Asia (Registry Operator for .mo)
+澳門
+
+// xn--mix082f ("Macao", Chinese, Simplified) : MO
+澳门
+
+// xn--mgbx4cd0ab ("Malaysia", Malay) : MY
+مليسيا
+
+// xn--mgb9awbf ("Oman", Arabic) : OM
+عمان
+
+// xn--mgbai9azgqp6j ("Pakistan", Urdu/Arabic) : PK
+پاکستان
+
+// xn--mgbai9a5eva00b ("Pakistan", Urdu/Arabic, variant) : PK
+پاكستان
+
+// xn--ygbi2ammx ("Falasteen", Arabic) : PS
+// The Palestinian National Internet Naming Authority (PNINA)
+// http://www.pnina.ps
+فلسطين
+
+// xn--90a3ac ("srb", Cyrillic) : RS
+// https://www.rnids.rs/en/domains/national-domains
+срб
+пр.срб
+орг.срб
+обр.срб
+од.срб
+упр.срб
+ак.срб
+
+// xn--p1ai ("rf", Russian-Cyrillic) : RU
+// http://www.cctld.ru/en/docs/rulesrf.php
+рф
+
+// xn--wgbl6a ("Qatar", Arabic) : QA
+// http://www.ict.gov.qa/
+قطر
+
+// xn--mgberp4a5d4ar ("AlSaudiah", Arabic) : SA
+// http://www.nic.net.sa/
+السعودية
+
+// xn--mgberp4a5d4a87g ("AlSaudiah", Arabic, variant)  : SA
+السعودیة
+
+// xn--mgbqly7c0a67fbc ("AlSaudiah", Arabic, variant) : SA
+السعودیۃ
+
+// xn--mgbqly7cvafr ("AlSaudiah", Arabic, variant) : SA
+السعوديه
+
+// xn--mgbpl2fh ("sudan", Arabic) : SD
+// Operated by .sd registry
+سودان
+
+// xn--yfro4i67o Singapore ("Singapore", Chinese) : SG
+新加坡
+
+// xn--clchc0ea0b2g2a9gcd ("Singapore", Tamil) : SG
+சிங்கப்பூர்
+
+// xn--ogbpf8fl ("Syria", Arabic) : SY
+سورية
+
+// xn--mgbtf8fl ("Syria", Arabic, variant) : SY
+سوريا
+
+// xn--o3cw4h ("Thai", Thai) : TH
+// http://www.thnic.co.th
+ไทย
+ศึกษา.ไทย
+ธุรกิจ.ไทย
+รัฐบาล.ไทย
+ทหาร.ไทย
+เน็ต.ไทย
+องค์กร.ไทย
+
+// xn--pgbs0dh ("Tunisia", Arabic) : TN
+// http://nic.tn
+تونس
+
+// xn--kpry57d ("Taiwan", Chinese, Traditional) : TW
+// http://www.twnic.net/english/dn/dn_07a.htm
+台灣
+
+// xn--kprw13d ("Taiwan", Chinese, Simplified) : TW
+// http://www.twnic.net/english/dn/dn_07a.htm
+台湾
+
+// xn--nnx388a ("Taiwan", Chinese, variant) : TW
+臺灣
+
+// xn--j1amh ("ukr", Cyrillic) : UA
+укр
+
+// xn--mgb2ddes ("AlYemen", Arabic) : YE
+اليمن
+
+// xxx : http://icmregistry.com
+xxx
+
+// ye : http://www.y.net.ye/services/domain_name.htm
+*.ye
+
+// za : http://www.zadna.org.za/content/page/domain-information
+ac.za
+agric.za
+alt.za
+co.za
+edu.za
+gov.za
+grondar.za
+law.za
+mil.za
+net.za
+ngo.za
+nis.za
+nom.za
+org.za
+school.za
+tm.za
+web.za
+
+// zm : https://zicta.zm/
+// Submitted by registry <info@zicta.zm>
+zm
+ac.zm
+biz.zm
+co.zm
+com.zm
+edu.zm
+gov.zm
+info.zm
+mil.zm
+net.zm
+org.zm
+sch.zm
+
+// zw : https://www.potraz.gov.zw/
+// Confirmed by registry <bmtengwa@potraz.gov.zw> 2017-01-25
+zw
+ac.zw
+co.zw
+gov.zw
+mil.zw
+org.zw
+
+
+// newGTLDs
+// List of new gTLDs imported from https://newgtlds.icann.org/newgtlds.csv on 2018-05-08T19:40:37Z
+// This list is auto-generated, don't edit it manually.
+
+// aaa : 2015-02-26 American Automobile Association, Inc.
+aaa
+
+// aarp : 2015-05-21 AARP
+aarp
+
+// abarth : 2015-07-30 Fiat Chrysler Automobiles N.V.
+abarth
+
+// abb : 2014-10-24 ABB Ltd
+abb
+
+// abbott : 2014-07-24 Abbott Laboratories, Inc.
+abbott
+
+// abbvie : 2015-07-30 AbbVie Inc.
+abbvie
+
+// abc : 2015-07-30 Disney Enterprises, Inc.
+abc
+
+// able : 2015-06-25 Able Inc.
+able
+
+// abogado : 2014-04-24 Minds + Machines Group Limited
+abogado
+
+// abudhabi : 2015-07-30 Abu Dhabi Systems and Information Centre
+abudhabi
+
+// academy : 2013-11-07 Binky Moon, LLC
+academy
+
+// accenture : 2014-08-15 Accenture plc
+accenture
+
+// accountant : 2014-11-20 dot Accountant Limited
+accountant
+
+// accountants : 2014-03-20 Binky Moon, LLC
+accountants
+
+// aco : 2015-01-08 ACO Severin Ahlmann GmbH & Co. KG
+aco
+
+// active : 2014-05-01 Active Network, LLC
+active
+
+// actor : 2013-12-12 United TLD Holdco Ltd.
+actor
+
+// adac : 2015-07-16 Allgemeiner Deutscher Automobil-Club e.V. (ADAC)
+adac
+
+// ads : 2014-12-04 Charleston Road Registry Inc.
+ads
+
+// adult : 2014-10-16 ICM Registry AD LLC
+adult
+
+// aeg : 2015-03-19 Aktiebolaget Electrolux
+aeg
+
+// aetna : 2015-05-21 Aetna Life Insurance Company
+aetna
+
+// afamilycompany : 2015-07-23 Johnson Shareholdings, Inc.
+afamilycompany
+
+// afl : 2014-10-02 Australian Football League
+afl
+
+// africa : 2014-03-24 ZA Central Registry NPC trading as Registry.Africa
+africa
+
+// agakhan : 2015-04-23 Fondation Aga Khan (Aga Khan Foundation)
+agakhan
+
+// agency : 2013-11-14 Binky Moon, LLC
+agency
+
+// aig : 2014-12-18 American International Group, Inc.
+aig
+
+// aigo : 2015-08-06 aigo Digital Technology Co,Ltd.
+aigo
+
+// airbus : 2015-07-30 Airbus S.A.S.
+airbus
+
+// airforce : 2014-03-06 United TLD Holdco Ltd.
+airforce
+
+// airtel : 2014-10-24 Bharti Airtel Limited
+airtel
+
+// akdn : 2015-04-23 Fondation Aga Khan (Aga Khan Foundation)
+akdn
+
+// alfaromeo : 2015-07-31 Fiat Chrysler Automobiles N.V.
+alfaromeo
+
+// alibaba : 2015-01-15 Alibaba Group Holding Limited
+alibaba
+
+// alipay : 2015-01-15 Alibaba Group Holding Limited
+alipay
+
+// allfinanz : 2014-07-03 Allfinanz Deutsche Vermögensberatung Aktiengesellschaft
+allfinanz
+
+// allstate : 2015-07-31 Allstate Fire and Casualty Insurance Company
+allstate
+
+// ally : 2015-06-18 Ally Financial Inc.
+ally
+
+// alsace : 2014-07-02 Region Grand Est
+alsace
+
+// alstom : 2015-07-30 ALSTOM
+alstom
+
+// americanexpress : 2015-07-31 American Express Travel Related Services Company, Inc.
+americanexpress
+
+// americanfamily : 2015-07-23 AmFam, Inc.
+americanfamily
+
+// amex : 2015-07-31 American Express Travel Related Services Company, Inc.
+amex
+
+// amfam : 2015-07-23 AmFam, Inc.
+amfam
+
+// amica : 2015-05-28 Amica Mutual Insurance Company
+amica
+
+// amsterdam : 2014-07-24 Gemeente Amsterdam
+amsterdam
+
+// analytics : 2014-12-18 Campus IP LLC
+analytics
+
+// android : 2014-08-07 Charleston Road Registry Inc.
+android
+
+// anquan : 2015-01-08 QIHOO 360 TECHNOLOGY CO. LTD.
+anquan
+
+// anz : 2015-07-31 Australia and New Zealand Banking Group Limited
+anz
+
+// aol : 2015-09-17 Oath Inc.
+aol
+
+// apartments : 2014-12-11 Binky Moon, LLC
+apartments
+
+// app : 2015-05-14 Charleston Road Registry Inc.
+app
+
+// apple : 2015-05-14 Apple Inc.
+apple
+
+// aquarelle : 2014-07-24 Aquarelle.com
+aquarelle
+
+// arab : 2015-11-12 League of Arab States
+arab
+
+// aramco : 2014-11-20 Aramco Services Company
+aramco
+
+// archi : 2014-02-06 Afilias plc
+archi
+
+// army : 2014-03-06 United TLD Holdco Ltd.
+army
+
+// art : 2016-03-24 UK Creative Ideas Limited
+art
+
+// arte : 2014-12-11 Association Relative à la Télévision Européenne G.E.I.E.
+arte
+
+// asda : 2015-07-31 Wal-Mart Stores, Inc.
+asda
+
+// associates : 2014-03-06 Binky Moon, LLC
+associates
+
+// athleta : 2015-07-30 The Gap, Inc.
+athleta
+
+// attorney : 2014-03-20 United TLD Holdco Ltd.
+attorney
+
+// auction : 2014-03-20 United TLD Holdco Ltd.
+auction
+
+// audi : 2015-05-21 AUDI Aktiengesellschaft
+audi
+
+// audible : 2015-06-25 Amazon Registry Services, Inc.
+audible
+
+// audio : 2014-03-20 Uniregistry, Corp.
+audio
+
+// auspost : 2015-08-13 Australian Postal Corporation
+auspost
+
+// author : 2014-12-18 Amazon Registry Services, Inc.
+author
+
+// auto : 2014-11-13 Cars Registry Limited
+auto
+
+// autos : 2014-01-09 DERAutos, LLC
+autos
+
+// avianca : 2015-01-08 Aerovias del Continente Americano S.A. Avianca
+avianca
+
+// aws : 2015-06-25 Amazon Registry Services, Inc.
+aws
+
+// axa : 2013-12-19 AXA SA
+axa
+
+// azure : 2014-12-18 Microsoft Corporation
+azure
+
+// baby : 2015-04-09 Johnson & Johnson Services, Inc.
+baby
+
+// baidu : 2015-01-08 Baidu, Inc.
+baidu
+
+// banamex : 2015-07-30 Citigroup Inc.
+banamex
+
+// bananarepublic : 2015-07-31 The Gap, Inc.
+bananarepublic
+
+// band : 2014-06-12 United TLD Holdco Ltd.
+band
+
+// bank : 2014-09-25 fTLD Registry Services LLC
+bank
+
+// bar : 2013-12-12 Punto 2012 Sociedad Anonima Promotora de Inversion de Capital Variable
+bar
+
+// barcelona : 2014-07-24 Municipi de Barcelona
+barcelona
+
+// barclaycard : 2014-11-20 Barclays Bank PLC
+barclaycard
+
+// barclays : 2014-11-20 Barclays Bank PLC
+barclays
+
+// barefoot : 2015-06-11 Gallo Vineyards, Inc.
+barefoot
+
+// bargains : 2013-11-14 Binky Moon, LLC
+bargains
+
+// baseball : 2015-10-29 MLB Advanced Media DH, LLC
+baseball
+
+// basketball : 2015-08-20 Fédération Internationale de Basketball (FIBA)
+basketball
+
+// bauhaus : 2014-04-17 Werkhaus GmbH
+bauhaus
+
+// bayern : 2014-01-23 Bayern Connect GmbH
+bayern
+
+// bbc : 2014-12-18 British Broadcasting Corporation
+bbc
+
+// bbt : 2015-07-23 BB&T Corporation
+bbt
+
+// bbva : 2014-10-02 BANCO BILBAO VIZCAYA ARGENTARIA, S.A.
+bbva
+
+// bcg : 2015-04-02 The Boston Consulting Group, Inc.
+bcg
+
+// bcn : 2014-07-24 Municipi de Barcelona
+bcn
+
+// beats : 2015-05-14 Beats Electronics, LLC
+beats
+
+// beauty : 2015-12-03 L'Oréal
+beauty
+
+// beer : 2014-01-09 Minds + Machines Group Limited
+beer
+
+// bentley : 2014-12-18 Bentley Motors Limited
+bentley
+
+// berlin : 2013-10-31 dotBERLIN GmbH & Co. KG
+berlin
+
+// best : 2013-12-19 BestTLD Pty Ltd
+best
+
+// bestbuy : 2015-07-31 BBY Solutions, Inc.
+bestbuy
+
+// bet : 2015-05-07 Afilias plc
+bet
+
+// bharti : 2014-01-09 Bharti Enterprises (Holding) Private Limited
+bharti
+
+// bible : 2014-06-19 American Bible Society
+bible
+
+// bid : 2013-12-19 dot Bid Limited
+bid
+
+// bike : 2013-08-27 Binky Moon, LLC
+bike
+
+// bing : 2014-12-18 Microsoft Corporation
+bing
+
+// bingo : 2014-12-04 Binky Moon, LLC
+bingo
+
+// bio : 2014-03-06 Afilias plc
+bio
+
+// black : 2014-01-16 Afilias plc
+black
+
+// blackfriday : 2014-01-16 Uniregistry, Corp.
+blackfriday
+
+// blockbuster : 2015-07-30 Dish DBS Corporation
+blockbuster
+
+// blog : 2015-05-14 Knock Knock WHOIS There, LLC
+blog
+
+// bloomberg : 2014-07-17 Bloomberg IP Holdings LLC
+bloomberg
+
+// blue : 2013-11-07 Afilias plc
+blue
+
+// bms : 2014-10-30 Bristol-Myers Squibb Company
+bms
+
+// bmw : 2014-01-09 Bayerische Motoren Werke Aktiengesellschaft
+bmw
+
+// bnl : 2014-07-24 Banca Nazionale del Lavoro
+bnl
+
+// bnpparibas : 2014-05-29 BNP Paribas
+bnpparibas
+
+// boats : 2014-12-04 DERBoats, LLC
+boats
+
+// boehringer : 2015-07-09 Boehringer Ingelheim International GmbH
+boehringer
+
+// bofa : 2015-07-31 Bank of America Corporation
+bofa
+
+// bom : 2014-10-16 Núcleo de Informação e Coordenação do Ponto BR - NIC.br
+bom
+
+// bond : 2014-06-05 Bond University Limited
+bond
+
+// boo : 2014-01-30 Charleston Road Registry Inc.
+boo
+
+// book : 2015-08-27 Amazon Registry Services, Inc.
+book
+
+// booking : 2015-07-16 Booking.com B.V.
+booking
+
+// bosch : 2015-06-18 Robert Bosch GMBH
+bosch
+
+// bostik : 2015-05-28 Bostik SA
+bostik
+
+// boston : 2015-12-10 Boston TLD Management, LLC
+boston
+
+// bot : 2014-12-18 Amazon Registry Services, Inc.
+bot
+
+// boutique : 2013-11-14 Binky Moon, LLC
+boutique
+
+// box : 2015-11-12 NS1 Limited
+box
+
+// bradesco : 2014-12-18 Banco Bradesco S.A.
+bradesco
+
+// bridgestone : 2014-12-18 Bridgestone Corporation
+bridgestone
+
+// broadway : 2014-12-22 Celebrate Broadway, Inc.
+broadway
+
+// broker : 2014-12-11 Dotbroker Registry Limited
+broker
+
+// brother : 2015-01-29 Brother Industries, Ltd.
+brother
+
+// brussels : 2014-02-06 DNS.be vzw
+brussels
+
+// budapest : 2013-11-21 Minds + Machines Group Limited
+budapest
+
+// bugatti : 2015-07-23 Bugatti International SA
+bugatti
+
+// build : 2013-11-07 Plan Bee LLC
+build
+
+// builders : 2013-11-07 Binky Moon, LLC
+builders
+
+// business : 2013-11-07 Binky Moon, LLC
+business
+
+// buy : 2014-12-18 Amazon Registry Services, Inc.
+buy
+
+// buzz : 2013-10-02 DOTSTRATEGY CO.
+buzz
+
+// bzh : 2014-02-27 Association www.bzh
+bzh
+
+// cab : 2013-10-24 Binky Moon, LLC
+cab
+
+// cafe : 2015-02-11 Binky Moon, LLC
+cafe
+
+// cal : 2014-07-24 Charleston Road Registry Inc.
+cal
+
+// call : 2014-12-18 Amazon Registry Services, Inc.
+call
+
+// calvinklein : 2015-07-30 PVH gTLD Holdings LLC
+calvinklein
+
+// cam : 2016-04-21 AC Webconnecting Holding B.V.
+cam
+
+// camera : 2013-08-27 Binky Moon, LLC
+camera
+
+// camp : 2013-11-07 Binky Moon, LLC
+camp
+
+// cancerresearch : 2014-05-15 Australian Cancer Research Foundation
+cancerresearch
+
+// canon : 2014-09-12 Canon Inc.
+canon
+
+// capetown : 2014-03-24 ZA Central Registry NPC trading as ZA Central Registry
+capetown
+
+// capital : 2014-03-06 Binky Moon, LLC
+capital
+
+// capitalone : 2015-08-06 Capital One Financial Corporation
+capitalone
+
+// car : 2015-01-22 Cars Registry Limited
+car
+
+// caravan : 2013-12-12 Caravan International, Inc.
+caravan
+
+// cards : 2013-12-05 Binky Moon, LLC
+cards
+
+// care : 2014-03-06 Binky Moon, LLC
+care
+
+// career : 2013-10-09 dotCareer LLC
+career
+
+// careers : 2013-10-02 Binky Moon, LLC
+careers
+
+// cars : 2014-11-13 Cars Registry Limited
+cars
+
+// cartier : 2014-06-23 Richemont DNS Inc.
+cartier
+
+// casa : 2013-11-21 Minds + Machines Group Limited
+casa
+
+// case : 2015-09-03 CNH Industrial N.V.
+case
+
+// caseih : 2015-09-03 CNH Industrial N.V.
+caseih
+
+// cash : 2014-03-06 Binky Moon, LLC
+cash
+
+// casino : 2014-12-18 Binky Moon, LLC
+casino
+
+// catering : 2013-12-05 Binky Moon, LLC
+catering
+
+// catholic : 2015-10-21 Pontificium Consilium de Comunicationibus Socialibus (PCCS) (Pontifical Council for Social Communication)
+catholic
+
+// cba : 2014-06-26 COMMONWEALTH BANK OF AUSTRALIA
+cba
+
+// cbn : 2014-08-22 The Christian Broadcasting Network, Inc.
+cbn
+
+// cbre : 2015-07-02 CBRE, Inc.
+cbre
+
+// cbs : 2015-08-06 CBS Domains Inc.
+cbs
+
+// ceb : 2015-04-09 The Corporate Executive Board Company
+ceb
+
+// center : 2013-11-07 Binky Moon, LLC
+center
+
+// ceo : 2013-11-07 CEOTLD Pty Ltd
+ceo
+
+// cern : 2014-06-05 European Organization for Nuclear Research ("CERN")
+cern
+
+// cfa : 2014-08-28 CFA Institute
+cfa
+
+// cfd : 2014-12-11 DotCFD Registry Limited
+cfd
+
+// chanel : 2015-04-09 Chanel International B.V.
+chanel
+
+// channel : 2014-05-08 Charleston Road Registry Inc.
+channel
+
+// charity : 2018-04-11 Corn Lake, LLC
+charity
+
+// chase : 2015-04-30 JPMorgan Chase Bank, National Association
+chase
+
+// chat : 2014-12-04 Binky Moon, LLC
+chat
+
+// cheap : 2013-11-14 Binky Moon, LLC
+cheap
+
+// chintai : 2015-06-11 CHINTAI Corporation
+chintai
+
+// christmas : 2013-11-21 Uniregistry, Corp.
+christmas
+
+// chrome : 2014-07-24 Charleston Road Registry Inc.
+chrome
+
+// chrysler : 2015-07-30 FCA US LLC.
+chrysler
+
+// church : 2014-02-06 Binky Moon, LLC
+church
+
+// cipriani : 2015-02-19 Hotel Cipriani Srl
+cipriani
+
+// circle : 2014-12-18 Amazon Registry Services, Inc.
+circle
+
+// cisco : 2014-12-22 Cisco Technology, Inc.
+cisco
+
+// citadel : 2015-07-23 Citadel Domain LLC
+citadel
+
+// citi : 2015-07-30 Citigroup Inc.
+citi
+
+// citic : 2014-01-09 CITIC Group Corporation
+citic
+
+// city : 2014-05-29 Binky Moon, LLC
+city
+
+// cityeats : 2014-12-11 Lifestyle Domain Holdings, Inc.
+cityeats
+
+// claims : 2014-03-20 Binky Moon, LLC
+claims
+
+// cleaning : 2013-12-05 Binky Moon, LLC
+cleaning
+
+// click : 2014-06-05 Uniregistry, Corp.
+click
+
+// clinic : 2014-03-20 Binky Moon, LLC
+clinic
+
+// clinique : 2015-10-01 The Estée Lauder Companies Inc.
+clinique
+
+// clothing : 2013-08-27 Binky Moon, LLC
+clothing
+
+// cloud : 2015-04-16 Aruba PEC S.p.A.
+cloud
+
+// club : 2013-11-08 .CLUB DOMAINS, LLC
+club
+
+// clubmed : 2015-06-25 Club Méditerranée S.A.
+clubmed
+
+// coach : 2014-10-09 Binky Moon, LLC
+coach
+
+// codes : 2013-10-31 Binky Moon, LLC
+codes
+
+// coffee : 2013-10-17 Binky Moon, LLC
+coffee
+
+// college : 2014-01-16 XYZ.COM LLC
+college
+
+// cologne : 2014-02-05 punkt.wien GmbH
+cologne
+
+// comcast : 2015-07-23 Comcast IP Holdings I, LLC
+comcast
+
+// commbank : 2014-06-26 COMMONWEALTH BANK OF AUSTRALIA
+commbank
+
+// community : 2013-12-05 Binky Moon, LLC
+community
+
+// company : 2013-11-07 Binky Moon, LLC
+company
+
+// compare : 2015-10-08 iSelect Ltd
+compare
+
+// computer : 2013-10-24 Binky Moon, LLC
+computer
+
+// comsec : 2015-01-08 VeriSign, Inc.
+comsec
+
+// condos : 2013-12-05 Binky Moon, LLC
+condos
+
+// construction : 2013-09-16 Binky Moon, LLC
+construction
+
+// consulting : 2013-12-05 United TLD Holdco Ltd.
+consulting
+
+// contact : 2015-01-08 Top Level Spectrum, Inc.
+contact
+
+// contractors : 2013-09-10 Binky Moon, LLC
+contractors
+
+// cooking : 2013-11-21 Minds + Machines Group Limited
+cooking
+
+// cookingchannel : 2015-07-02 Lifestyle Domain Holdings, Inc.
+cookingchannel
+
+// cool : 2013-11-14 Binky Moon, LLC
+cool
+
+// corsica : 2014-09-25 Collectivité de Corse
+corsica
+
+// country : 2013-12-19 DotCountry LLC
+country
+
+// coupon : 2015-02-26 Amazon Registry Services, Inc.
+coupon
+
+// coupons : 2015-03-26 Binky Moon, LLC
+coupons
+
+// courses : 2014-12-04 OPEN UNIVERSITIES AUSTRALIA PTY LTD
+courses
+
+// credit : 2014-03-20 Binky Moon, LLC
+credit
+
+// creditcard : 2014-03-20 Binky Moon, LLC
+creditcard
+
+// creditunion : 2015-01-22 CUNA Performance Resources, LLC
+creditunion
+
+// cricket : 2014-10-09 dot Cricket Limited
+cricket
+
+// crown : 2014-10-24 Crown Equipment Corporation
+crown
+
+// crs : 2014-04-03 Federated Co-operatives Limited
+crs
+
+// cruise : 2015-12-10 Viking River Cruises (Bermuda) Ltd.
+cruise
+
+// cruises : 2013-12-05 Binky Moon, LLC
+cruises
+
+// csc : 2014-09-25 Alliance-One Services, Inc.
+csc
+
+// cuisinella : 2014-04-03 SALM S.A.S.
+cuisinella
+
+// cymru : 2014-05-08 Nominet UK
+cymru
+
+// cyou : 2015-01-22 Beijing Gamease Age Digital Technology Co., Ltd.
+cyou
+
+// dabur : 2014-02-06 Dabur India Limited
+dabur
+
+// dad : 2014-01-23 Charleston Road Registry Inc.
+dad
+
+// dance : 2013-10-24 United TLD Holdco Ltd.
+dance
+
+// data : 2016-06-02 Dish DBS Corporation
+data
+
+// date : 2014-11-20 dot Date Limited
+date
+
+// dating : 2013-12-05 Binky Moon, LLC
+dating
+
+// datsun : 2014-03-27 NISSAN MOTOR CO., LTD.
+datsun
+
+// day : 2014-01-30 Charleston Road Registry Inc.
+day
+
+// dclk : 2014-11-20 Charleston Road Registry Inc.
+dclk
+
+// dds : 2015-05-07 Minds + Machines Group Limited
+dds
+
+// deal : 2015-06-25 Amazon Registry Services, Inc.
+deal
+
+// dealer : 2014-12-22 Dealer Dot Com, Inc.
+dealer
+
+// deals : 2014-05-22 Binky Moon, LLC
+deals
+
+// degree : 2014-03-06 United TLD Holdco Ltd.
+degree
+
+// delivery : 2014-09-11 Binky Moon, LLC
+delivery
+
+// dell : 2014-10-24 Dell Inc.
+dell
+
+// deloitte : 2015-07-31 Deloitte Touche Tohmatsu
+deloitte
+
+// delta : 2015-02-19 Delta Air Lines, Inc.
+delta
+
+// democrat : 2013-10-24 United TLD Holdco Ltd.
+democrat
+
+// dental : 2014-03-20 Binky Moon, LLC
+dental
+
+// dentist : 2014-03-20 United TLD Holdco Ltd.
+dentist
+
+// desi : 2013-11-14 Desi Networks LLC
+desi
+
+// design : 2014-11-07 Top Level Design, LLC
+design
+
+// dev : 2014-10-16 Charleston Road Registry Inc.
+dev
+
+// dhl : 2015-07-23 Deutsche Post AG
+dhl
+
+// diamonds : 2013-09-22 Binky Moon, LLC
+diamonds
+
+// diet : 2014-06-26 Uniregistry, Corp.
+diet
+
+// digital : 2014-03-06 Binky Moon, LLC
+digital
+
+// direct : 2014-04-10 Binky Moon, LLC
+direct
+
+// directory : 2013-09-20 Binky Moon, LLC
+directory
+
+// discount : 2014-03-06 Binky Moon, LLC
+discount
+
+// discover : 2015-07-23 Discover Financial Services
+discover
+
+// dish : 2015-07-30 Dish DBS Corporation
+dish
+
+// diy : 2015-11-05 Lifestyle Domain Holdings, Inc.
+diy
+
+// dnp : 2013-12-13 Dai Nippon Printing Co., Ltd.
+dnp
+
+// docs : 2014-10-16 Charleston Road Registry Inc.
+docs
+
+// doctor : 2016-06-02 Binky Moon, LLC
+doctor
+
+// dodge : 2015-07-30 FCA US LLC.
+dodge
+
+// dog : 2014-12-04 Binky Moon, LLC
+dog
+
+// doha : 2014-09-18 Communications Regulatory Authority (CRA)
+doha
+
+// domains : 2013-10-17 Binky Moon, LLC
+domains
+
+// dot : 2015-05-21 Dish DBS Corporation
+dot
+
+// download : 2014-11-20 dot Support Limited
+download
+
+// drive : 2015-03-05 Charleston Road Registry Inc.
+drive
+
+// dtv : 2015-06-04 Dish DBS Corporation
+dtv
+
+// dubai : 2015-01-01 Dubai Smart Government Department
+dubai
+
+// duck : 2015-07-23 Johnson Shareholdings, Inc.
+duck
+
+// dunlop : 2015-07-02 The Goodyear Tire & Rubber Company
+dunlop
+
+// duns : 2015-08-06 The Dun & Bradstreet Corporation
+duns
+
+// dupont : 2015-06-25 E. I. du Pont de Nemours and Company
+dupont
+
+// durban : 2014-03-24 ZA Central Registry NPC trading as ZA Central Registry
+durban
+
+// dvag : 2014-06-23 Deutsche Vermögensberatung Aktiengesellschaft DVAG
+dvag
+
+// dvr : 2016-05-26 Hughes Satellite Systems Corporation
+dvr
+
+// earth : 2014-12-04 Interlink Co., Ltd.
+earth
+
+// eat : 2014-01-23 Charleston Road Registry Inc.
+eat
+
+// eco : 2016-07-08 Big Room Inc.
+eco
+
+// edeka : 2014-12-18 EDEKA Verband kaufmännischer Genossenschaften e.V.
+edeka
+
+// education : 2013-11-07 Binky Moon, LLC
+education
+
+// email : 2013-10-31 Binky Moon, LLC
+email
+
+// emerck : 2014-04-03 Merck KGaA
+emerck
+
+// energy : 2014-09-11 Binky Moon, LLC
+energy
+
+// engineer : 2014-03-06 United TLD Holdco Ltd.
+engineer
+
+// engineering : 2014-03-06 Binky Moon, LLC
+engineering
+
+// enterprises : 2013-09-20 Binky Moon, LLC
+enterprises
+
+// epson : 2014-12-04 Seiko Epson Corporation
+epson
+
+// equipment : 2013-08-27 Binky Moon, LLC
+equipment
+
+// ericsson : 2015-07-09 Telefonaktiebolaget L M Ericsson
+ericsson
+
+// erni : 2014-04-03 ERNI Group Holding AG
+erni
+
+// esq : 2014-05-08 Charleston Road Registry Inc.
+esq
+
+// estate : 2013-08-27 Binky Moon, LLC
+estate
+
+// esurance : 2015-07-23 Esurance Insurance Company
+esurance
+
+// etisalat : 2015-09-03 Emirates Telecommunications Corporation (trading as Etisalat)
+etisalat
+
+// eurovision : 2014-04-24 European Broadcasting Union (EBU)
+eurovision
+
+// eus : 2013-12-12 Puntueus Fundazioa
+eus
+
+// events : 2013-12-05 Binky Moon, LLC
+events
+
+// everbank : 2014-05-15 EverBank
+everbank
+
+// exchange : 2014-03-06 Binky Moon, LLC
+exchange
+
+// expert : 2013-11-21 Binky Moon, LLC
+expert
+
+// exposed : 2013-12-05 Binky Moon, LLC
+exposed
+
+// express : 2015-02-11 Binky Moon, LLC
+express
+
+// extraspace : 2015-05-14 Extra Space Storage LLC
+extraspace
+
+// fage : 2014-12-18 Fage International S.A.
+fage
+
+// fail : 2014-03-06 Binky Moon, LLC
+fail
+
+// fairwinds : 2014-11-13 FairWinds Partners, LLC
+fairwinds
+
+// faith : 2014-11-20 dot Faith Limited
+faith
+
+// family : 2015-04-02 United TLD Holdco Ltd.
+family
+
+// fan : 2014-03-06 Asiamix Digital Limited
+fan
+
+// fans : 2014-11-07 Asiamix Digital Limited
+fans
+
+// farm : 2013-11-07 Binky Moon, LLC
+farm
+
+// farmers : 2015-07-09 Farmers Insurance Exchange
+farmers
+
+// fashion : 2014-07-03 Minds + Machines Group Limited
+fashion
+
+// fast : 2014-12-18 Amazon Registry Services, Inc.
+fast
+
+// fedex : 2015-08-06 Federal Express Corporation
+fedex
+
+// feedback : 2013-12-19 Top Level Spectrum, Inc.
+feedback
+
+// ferrari : 2015-07-31 Fiat Chrysler Automobiles N.V.
+ferrari
+
+// ferrero : 2014-12-18 Ferrero Trading Lux S.A.
+ferrero
+
+// fiat : 2015-07-31 Fiat Chrysler Automobiles N.V.
+fiat
+
+// fidelity : 2015-07-30 Fidelity Brokerage Services LLC
+fidelity
+
+// fido : 2015-08-06 Rogers Communications Canada Inc.
+fido
+
+// film : 2015-01-08 Motion Picture Domain Registry Pty Ltd
+film
+
+// final : 2014-10-16 Núcleo de Informação e Coordenação do Ponto BR - NIC.br
+final
+
+// finance : 2014-03-20 Binky Moon, LLC
+finance
+
+// financial : 2014-03-06 Binky Moon, LLC
+financial
+
+// fire : 2015-06-25 Amazon Registry Services, Inc.
+fire
+
+// firestone : 2014-12-18 Bridgestone Licensing Services, Inc
+firestone
+
+// firmdale : 2014-03-27 Firmdale Holdings Limited
+firmdale
+
+// fish : 2013-12-12 Binky Moon, LLC
+fish
+
+// fishing : 2013-11-21 Minds + Machines Group Limited
+fishing
+
+// fit : 2014-11-07 Minds + Machines Group Limited
+fit
+
+// fitness : 2014-03-06 Binky Moon, LLC
+fitness
+
+// flickr : 2015-04-02 Yahoo! Domain Services Inc.
+flickr
+
+// flights : 2013-12-05 Binky Moon, LLC
+flights
+
+// flir : 2015-07-23 FLIR Systems, Inc.
+flir
+
+// florist : 2013-11-07 Binky Moon, LLC
+florist
+
+// flowers : 2014-10-09 Uniregistry, Corp.
+flowers
+
+// fly : 2014-05-08 Charleston Road Registry Inc.
+fly
+
+// foo : 2014-01-23 Charleston Road Registry Inc.
+foo
+
+// food : 2016-04-21 Lifestyle Domain Holdings, Inc.
+food
+
+// foodnetwork : 2015-07-02 Lifestyle Domain Holdings, Inc.
+foodnetwork
+
+// football : 2014-12-18 Binky Moon, LLC
+football
+
+// ford : 2014-11-13 Ford Motor Company
+ford
+
+// forex : 2014-12-11 Dotforex Registry Limited
+forex
+
+// forsale : 2014-05-22 United TLD Holdco Ltd.
+forsale
+
+// forum : 2015-04-02 Fegistry, LLC
+forum
+
+// foundation : 2013-12-05 Binky Moon, LLC
+foundation
+
+// fox : 2015-09-11 FOX Registry, LLC
+fox
+
+// free : 2015-12-10 Amazon Registry Services, Inc.
+free
+
+// fresenius : 2015-07-30 Fresenius Immobilien-Verwaltungs-GmbH
+fresenius
+
+// frl : 2014-05-15 FRLregistry B.V.
+frl
+
+// frogans : 2013-12-19 OP3FT
+frogans
+
+// frontdoor : 2015-07-02 Lifestyle Domain Holdings, Inc.
+frontdoor
+
+// frontier : 2015-02-05 Frontier Communications Corporation
+frontier
+
+// ftr : 2015-07-16 Frontier Communications Corporation
+ftr
+
+// fujitsu : 2015-07-30 Fujitsu Limited
+fujitsu
+
+// fujixerox : 2015-07-23 Xerox DNHC LLC
+fujixerox
+
+// fun : 2016-01-14 DotSpace Inc.
+fun
+
+// fund : 2014-03-20 Binky Moon, LLC
+fund
+
+// furniture : 2014-03-20 Binky Moon, LLC
+furniture
+
+// futbol : 2013-09-20 United TLD Holdco Ltd.
+futbol
+
+// fyi : 2015-04-02 Binky Moon, LLC
+fyi
+
+// gal : 2013-11-07 Asociación puntoGAL
+gal
+
+// gallery : 2013-09-13 Binky Moon, LLC
+gallery
+
+// gallo : 2015-06-11 Gallo Vineyards, Inc.
+gallo
+
+// gallup : 2015-02-19 Gallup, Inc.
+gallup
+
+// game : 2015-05-28 Uniregistry, Corp.
+game
+
+// games : 2015-05-28 United TLD Holdco Ltd.
+games
+
+// gap : 2015-07-31 The Gap, Inc.
+gap
+
+// garden : 2014-06-26 Minds + Machines Group Limited
+garden
+
+// gbiz : 2014-07-17 Charleston Road Registry Inc.
+gbiz
+
+// gdn : 2014-07-31 Joint Stock Company "Navigation-information systems"
+gdn
+
+// gea : 2014-12-04 GEA Group Aktiengesellschaft
+gea
+
+// gent : 2014-01-23 COMBELL NV
+gent
+
+// genting : 2015-03-12 Resorts World Inc Pte. Ltd.
+genting
+
+// george : 2015-07-31 Wal-Mart Stores, Inc.
+george
+
+// ggee : 2014-01-09 GMO Internet, Inc.
+ggee
+
+// gift : 2013-10-17 DotGift, LLC
+gift
+
+// gifts : 2014-07-03 Binky Moon, LLC
+gifts
+
+// gives : 2014-03-06 United TLD Holdco Ltd.
+gives
+
+// giving : 2014-11-13 Giving Limited
+giving
+
+// glade : 2015-07-23 Johnson Shareholdings, Inc.
+glade
+
+// glass : 2013-11-07 Binky Moon, LLC
+glass
+
+// gle : 2014-07-24 Charleston Road Registry Inc.
+gle
+
+// global : 2014-04-17 Dot Global Domain Registry Limited
+global
+
+// globo : 2013-12-19 Globo Comunicação e Participações S.A
+globo
+
+// gmail : 2014-05-01 Charleston Road Registry Inc.
+gmail
+
+// gmbh : 2016-01-29 Binky Moon, LLC
+gmbh
+
+// gmo : 2014-01-09 GMO Internet Pte. Ltd.
+gmo
+
+// gmx : 2014-04-24 1&1 Mail & Media GmbH
+gmx
+
+// godaddy : 2015-07-23 Go Daddy East, LLC
+godaddy
+
+// gold : 2015-01-22 Binky Moon, LLC
+gold
+
+// goldpoint : 2014-11-20 YODOBASHI CAMERA CO.,LTD.
+goldpoint
+
+// golf : 2014-12-18 Binky Moon, LLC
+golf
+
+// goo : 2014-12-18 NTT Resonant Inc.
+goo
+
+// goodyear : 2015-07-02 The Goodyear Tire & Rubber Company
+goodyear
+
+// goog : 2014-11-20 Charleston Road Registry Inc.
+goog
+
+// google : 2014-07-24 Charleston Road Registry Inc.
+google
+
+// gop : 2014-01-16 Republican State Leadership Committee, Inc.
+gop
+
+// got : 2014-12-18 Amazon Registry Services, Inc.
+got
+
+// grainger : 2015-05-07 Grainger Registry Services, LLC
+grainger
+
+// graphics : 2013-09-13 Binky Moon, LLC
+graphics
+
+// gratis : 2014-03-20 Binky Moon, LLC
+gratis
+
+// green : 2014-05-08 Afilias plc
+green
+
+// gripe : 2014-03-06 Binky Moon, LLC
+gripe
+
+// grocery : 2016-06-16 Wal-Mart Stores, Inc.
+grocery
+
+// group : 2014-08-15 Binky Moon, LLC
+group
+
+// guardian : 2015-07-30 The Guardian Life Insurance Company of America
+guardian
+
+// gucci : 2014-11-13 Guccio Gucci S.p.a.
+gucci
+
+// guge : 2014-08-28 Charleston Road Registry Inc.
+guge
+
+// guide : 2013-09-13 Binky Moon, LLC
+guide
+
+// guitars : 2013-11-14 Uniregistry, Corp.
+guitars
+
+// guru : 2013-08-27 Binky Moon, LLC
+guru
+
+// hair : 2015-12-03 L'Oréal
+hair
+
+// hamburg : 2014-02-20 Hamburg Top-Level-Domain GmbH
+hamburg
+
+// hangout : 2014-11-13 Charleston Road Registry Inc.
+hangout
+
+// haus : 2013-12-05 United TLD Holdco Ltd.
+haus
+
+// hbo : 2015-07-30 HBO Registry Services, Inc.
+hbo
+
+// hdfc : 2015-07-30 HOUSING DEVELOPMENT FINANCE CORPORATION LIMITED
+hdfc
+
+// hdfcbank : 2015-02-12 HDFC Bank Limited
+hdfcbank
+
+// health : 2015-02-11 DotHealth, LLC
+health
+
+// healthcare : 2014-06-12 Binky Moon, LLC
+healthcare
+
+// help : 2014-06-26 Uniregistry, Corp.
+help
+
+// helsinki : 2015-02-05 City of Helsinki
+helsinki
+
+// here : 2014-02-06 Charleston Road Registry Inc.
+here
+
+// hermes : 2014-07-10 HERMES INTERNATIONAL
+hermes
+
+// hgtv : 2015-07-02 Lifestyle Domain Holdings, Inc.
+hgtv
+
+// hiphop : 2014-03-06 Uniregistry, Corp.
+hiphop
+
+// hisamitsu : 2015-07-16 Hisamitsu Pharmaceutical Co.,Inc.
+hisamitsu
+
+// hitachi : 2014-10-31 Hitachi, Ltd.
+hitachi
+
+// hiv : 2014-03-13 Uniregistry, Corp.
+hiv
+
+// hkt : 2015-05-14 PCCW-HKT DataCom Services Limited
+hkt
+
+// hockey : 2015-03-19 Binky Moon, LLC
+hockey
+
+// holdings : 2013-08-27 Binky Moon, LLC
+holdings
+
+// holiday : 2013-11-07 Binky Moon, LLC
+holiday
+
+// homedepot : 2015-04-02 Home Depot Product Authority, LLC
+homedepot
+
+// homegoods : 2015-07-16 The TJX Companies, Inc.
+homegoods
+
+// homes : 2014-01-09 DERHomes, LLC
+homes
+
+// homesense : 2015-07-16 The TJX Companies, Inc.
+homesense
+
+// honda : 2014-12-18 Honda Motor Co., Ltd.
+honda
+
+// honeywell : 2015-07-23 Honeywell GTLD LLC
+honeywell
+
+// horse : 2013-11-21 Minds + Machines Group Limited
+horse
+
+// hospital : 2016-10-20 Binky Moon, LLC
+hospital
+
+// host : 2014-04-17 DotHost Inc.
+host
+
+// hosting : 2014-05-29 Uniregistry, Corp.
+hosting
+
+// hot : 2015-08-27 Amazon Registry Services, Inc.
+hot
+
+// hoteles : 2015-03-05 Travel Reservations SRL
+hoteles
+
+// hotels : 2016-04-07 Booking.com B.V.
+hotels
+
+// hotmail : 2014-12-18 Microsoft Corporation
+hotmail
+
+// house : 2013-11-07 Binky Moon, LLC
+house
+
+// how : 2014-01-23 Charleston Road Registry Inc.
+how
+
+// hsbc : 2014-10-24 HSBC Global Services (UK) Limited
+hsbc
+
+// hughes : 2015-07-30 Hughes Satellite Systems Corporation
+hughes
+
+// hyatt : 2015-07-30 Hyatt GTLD, L.L.C.
+hyatt
+
+// hyundai : 2015-07-09 Hyundai Motor Company
+hyundai
+
+// ibm : 2014-07-31 International Business Machines Corporation
+ibm
+
+// icbc : 2015-02-19 Industrial and Commercial Bank of China Limited
+icbc
+
+// ice : 2014-10-30 IntercontinentalExchange, Inc.
+ice
+
+// icu : 2015-01-08 ShortDot SA
+icu
+
+// ieee : 2015-07-23 IEEE Global LLC
+ieee
+
+// ifm : 2014-01-30 ifm electronic gmbh
+ifm
+
+// ikano : 2015-07-09 Ikano S.A.
+ikano
+
+// imamat : 2015-08-06 Fondation Aga Khan (Aga Khan Foundation)
+imamat
+
+// imdb : 2015-06-25 Amazon Registry Services, Inc.
+imdb
+
+// immo : 2014-07-10 Binky Moon, LLC
+immo
+
+// immobilien : 2013-11-07 United TLD Holdco Ltd.
+immobilien
+
+// inc : 2018-03-10 GTLD Limited
+inc
+
+// industries : 2013-12-05 Binky Moon, LLC
+industries
+
+// infiniti : 2014-03-27 NISSAN MOTOR CO., LTD.
+infiniti
+
+// ing : 2014-01-23 Charleston Road Registry Inc.
+ing
+
+// ink : 2013-12-05 Top Level Design, LLC
+ink
+
+// institute : 2013-11-07 Binky Moon, LLC
+institute
+
+// insurance : 2015-02-19 fTLD Registry Services LLC
+insurance
+
+// insure : 2014-03-20 Binky Moon, LLC
+insure
+
+// intel : 2015-08-06 Intel Corporation
+intel
+
+// international : 2013-11-07 Binky Moon, LLC
+international
+
+// intuit : 2015-07-30 Intuit Administrative Services, Inc.
+intuit
+
+// investments : 2014-03-20 Binky Moon, LLC
+investments
+
+// ipiranga : 2014-08-28 Ipiranga Produtos de Petroleo S.A.
+ipiranga
+
+// irish : 2014-08-07 Binky Moon, LLC
+irish
+
+// iselect : 2015-02-11 iSelect Ltd
+iselect
+
+// ismaili : 2015-08-06 Fondation Aga Khan (Aga Khan Foundation)
+ismaili
+
+// ist : 2014-08-28 Istanbul Metropolitan Municipality
+ist
+
+// istanbul : 2014-08-28 Istanbul Metropolitan Municipality
+istanbul
+
+// itau : 2014-10-02 Itau Unibanco Holding S.A.
+itau
+
+// itv : 2015-07-09 ITV Services Limited
+itv
+
+// iveco : 2015-09-03 CNH Industrial N.V.
+iveco
+
+// jaguar : 2014-11-13 Jaguar Land Rover Ltd
+jaguar
+
+// java : 2014-06-19 Oracle Corporation
+java
+
+// jcb : 2014-11-20 JCB Co., Ltd.
+jcb
+
+// jcp : 2015-04-23 JCP Media, Inc.
+jcp
+
+// jeep : 2015-07-30 FCA US LLC.
+jeep
+
+// jetzt : 2014-01-09 Binky Moon, LLC
+jetzt
+
+// jewelry : 2015-03-05 Binky Moon, LLC
+jewelry
+
+// jio : 2015-04-02 Reliance Industries Limited
+jio
+
+// jll : 2015-04-02 Jones Lang LaSalle Incorporated
+jll
+
+// jmp : 2015-03-26 Matrix IP LLC
+jmp
+
+// jnj : 2015-06-18 Johnson & Johnson Services, Inc.
+jnj
+
+// joburg : 2014-03-24 ZA Central Registry NPC trading as ZA Central Registry
+joburg
+
+// jot : 2014-12-18 Amazon Registry Services, Inc.
+jot
+
+// joy : 2014-12-18 Amazon Registry Services, Inc.
+joy
+
+// jpmorgan : 2015-04-30 JPMorgan Chase Bank, National Association
+jpmorgan
+
+// jprs : 2014-09-18 Japan Registry Services Co., Ltd.
+jprs
+
+// juegos : 2014-03-20 Uniregistry, Corp.
+juegos
+
+// juniper : 2015-07-30 JUNIPER NETWORKS, INC.
+juniper
+
+// kaufen : 2013-11-07 United TLD Holdco Ltd.
+kaufen
+
+// kddi : 2014-09-12 KDDI CORPORATION
+kddi
+
+// kerryhotels : 2015-04-30 Kerry Trading Co. Limited
+kerryhotels
+
+// kerrylogistics : 2015-04-09 Kerry Trading Co. Limited
+kerrylogistics
+
+// kerryproperties : 2015-04-09 Kerry Trading Co. Limited
+kerryproperties
+
+// kfh : 2014-12-04 Kuwait Finance House
+kfh
+
+// kia : 2015-07-09 KIA MOTORS CORPORATION
+kia
+
+// kim : 2013-09-23 Afilias plc
+kim
+
+// kinder : 2014-11-07 Ferrero Trading Lux S.A.
+kinder
+
+// kindle : 2015-06-25 Amazon Registry Services, Inc.
+kindle
+
+// kitchen : 2013-09-20 Binky Moon, LLC
+kitchen
+
+// kiwi : 2013-09-20 DOT KIWI LIMITED
+kiwi
+
+// koeln : 2014-01-09 punkt.wien GmbH
+koeln
+
+// komatsu : 2015-01-08 Komatsu Ltd.
+komatsu
+
+// kosher : 2015-08-20 Kosher Marketing Assets LLC
+kosher
+
+// kpmg : 2015-04-23 KPMG International Cooperative (KPMG International Genossenschaft)
+kpmg
+
+// kpn : 2015-01-08 Koninklijke KPN N.V.
+kpn
+
+// krd : 2013-12-05 KRG Department of Information Technology
+krd
+
+// kred : 2013-12-19 KredTLD Pty Ltd
+kred
+
+// kuokgroup : 2015-04-09 Kerry Trading Co. Limited
+kuokgroup
+
+// kyoto : 2014-11-07 Academic Institution: Kyoto Jyoho Gakuen
+kyoto
+
+// lacaixa : 2014-01-09 Fundación Bancaria Caixa d’Estalvis i Pensions de Barcelona, “la Caixa”
+lacaixa
+
+// ladbrokes : 2015-08-06 LADBROKES INTERNATIONAL PLC
+ladbrokes
+
+// lamborghini : 2015-06-04 Automobili Lamborghini S.p.A.
+lamborghini
+
+// lamer : 2015-10-01 The Estée Lauder Companies Inc.
+lamer
+
+// lancaster : 2015-02-12 LANCASTER
+lancaster
+
+// lancia : 2015-07-31 Fiat Chrysler Automobiles N.V.
+lancia
+
+// lancome : 2015-07-23 L'Oréal
+lancome
+
+// land : 2013-09-10 Binky Moon, LLC
+land
+
+// landrover : 2014-11-13 Jaguar Land Rover Ltd
+landrover
+
+// lanxess : 2015-07-30 LANXESS Corporation
+lanxess
+
+// lasalle : 2015-04-02 Jones Lang LaSalle Incorporated
+lasalle
+
+// lat : 2014-10-16 ECOM-LAC Federaciòn de Latinoamèrica y el Caribe para Internet y el Comercio Electrònico
+lat
+
+// latino : 2015-07-30 Dish DBS Corporation
+latino
+
+// latrobe : 2014-06-16 La Trobe University
+latrobe
+
+// law : 2015-01-22 Minds + Machines Group Limited
+law
+
+// lawyer : 2014-03-20 United TLD Holdco Ltd.
+lawyer
+
+// lds : 2014-03-20 IRI Domain Management, LLC ("Applicant")
+lds
+
+// lease : 2014-03-06 Binky Moon, LLC
+lease
+
+// leclerc : 2014-08-07 A.C.D. LEC Association des Centres Distributeurs Edouard Leclerc
+leclerc
+
+// lefrak : 2015-07-16 LeFrak Organization, Inc.
+lefrak
+
+// legal : 2014-10-16 Binky Moon, LLC
+legal
+
+// lego : 2015-07-16 LEGO Juris A/S
+lego
+
+// lexus : 2015-04-23 TOYOTA MOTOR CORPORATION
+lexus
+
+// lgbt : 2014-05-08 Afilias plc
+lgbt
+
+// liaison : 2014-10-02 Liaison Technologies, Incorporated
+liaison
+
+// lidl : 2014-09-18 Schwarz Domains und Services GmbH & Co. KG
+lidl
+
+// life : 2014-02-06 Binky Moon, LLC
+life
+
+// lifeinsurance : 2015-01-15 American Council of Life Insurers
+lifeinsurance
+
+// lifestyle : 2014-12-11 Lifestyle Domain Holdings, Inc.
+lifestyle
+
+// lighting : 2013-08-27 Binky Moon, LLC
+lighting
+
+// like : 2014-12-18 Amazon Registry Services, Inc.
+like
+
+// lilly : 2015-07-31 Eli Lilly and Company
+lilly
+
+// limited : 2014-03-06 Binky Moon, LLC
+limited
+
+// limo : 2013-10-17 Binky Moon, LLC
+limo
+
+// lincoln : 2014-11-13 Ford Motor Company
+lincoln
+
+// linde : 2014-12-04 Linde Aktiengesellschaft
+linde
+
+// link : 2013-11-14 Uniregistry, Corp.
+link
+
+// lipsy : 2015-06-25 Lipsy Ltd
+lipsy
+
+// live : 2014-12-04 United TLD Holdco Ltd.
+live
+
+// living : 2015-07-30 Lifestyle Domain Holdings, Inc.
+living
+
+// lixil : 2015-03-19 LIXIL Group Corporation
+lixil
+
+// llc : 2017-12-14 Afilias plc
+llc
+
+// loan : 2014-11-20 dot Loan Limited
+loan
+
+// loans : 2014-03-20 Binky Moon, LLC
+loans
+
+// locker : 2015-06-04 Dish DBS Corporation
+locker
+
+// locus : 2015-06-25 Locus Analytics LLC
+locus
+
+// loft : 2015-07-30 Annco, Inc.
+loft
+
+// lol : 2015-01-30 Uniregistry, Corp.
+lol
+
+// london : 2013-11-14 Dot London Domains Limited
+london
+
+// lotte : 2014-11-07 Lotte Holdings Co., Ltd.
+lotte
+
+// lotto : 2014-04-10 Afilias plc
+lotto
+
+// love : 2014-12-22 Merchant Law Group LLP
+love
+
+// lpl : 2015-07-30 LPL Holdings, Inc.
+lpl
+
+// lplfinancial : 2015-07-30 LPL Holdings, Inc.
+lplfinancial
+
+// ltd : 2014-09-25 Binky Moon, LLC
+ltd
+
+// ltda : 2014-04-17 InterNetX, Corp
+ltda
+
+// lundbeck : 2015-08-06 H. Lundbeck A/S
+lundbeck
+
+// lupin : 2014-11-07 LUPIN LIMITED
+lupin
+
+// luxe : 2014-01-09 Minds + Machines Group Limited
+luxe
+
+// luxury : 2013-10-17 Luxury Partners, LLC
+luxury
+
+// macys : 2015-07-31 Macys, Inc.
+macys
+
+// madrid : 2014-05-01 Comunidad de Madrid
+madrid
+
+// maif : 2014-10-02 Mutuelle Assurance Instituteur France (MAIF)
+maif
+
+// maison : 2013-12-05 Binky Moon, LLC
+maison
+
+// makeup : 2015-01-15 L'Oréal
+makeup
+
+// man : 2014-12-04 MAN SE
+man
+
+// management : 2013-11-07 Binky Moon, LLC
+management
+
+// mango : 2013-10-24 PUNTO FA S.L.
+mango
+
+// map : 2016-06-09 Charleston Road Registry Inc.
+map
+
+// market : 2014-03-06 United TLD Holdco Ltd.
+market
+
+// marketing : 2013-11-07 Binky Moon, LLC
+marketing
+
+// markets : 2014-12-11 Dotmarkets Registry Limited
+markets
+
+// marriott : 2014-10-09 Marriott Worldwide Corporation
+marriott
+
+// marshalls : 2015-07-16 The TJX Companies, Inc.
+marshalls
+
+// maserati : 2015-07-31 Fiat Chrysler Automobiles N.V.
+maserati
+
+// mattel : 2015-08-06 Mattel Sites, Inc.
+mattel
+
+// mba : 2015-04-02 Binky Moon, LLC
+mba
+
+// mckinsey : 2015-07-31 McKinsey Holdings, Inc.
+mckinsey
+
+// med : 2015-08-06 Medistry LLC
+med
+
+// media : 2014-03-06 Binky Moon, LLC
+media
+
+// meet : 2014-01-16 Charleston Road Registry Inc.
+meet
+
+// melbourne : 2014-05-29 The Crown in right of the State of Victoria, represented by its Department of State Development, Business and Innovation
+melbourne
+
+// meme : 2014-01-30 Charleston Road Registry Inc.
+meme
+
+// memorial : 2014-10-16 Dog Beach, LLC
+memorial
+
+// men : 2015-02-26 Exclusive Registry Limited
+men
+
+// menu : 2013-09-11 Wedding TLD2, LLC
+menu
+
+// merckmsd : 2016-07-14 MSD Registry Holdings, Inc.
+merckmsd
+
+// metlife : 2015-05-07 MetLife Services and Solutions, LLC
+metlife
+
+// miami : 2013-12-19 Minds + Machines Group Limited
+miami
+
+// microsoft : 2014-12-18 Microsoft Corporation
+microsoft
+
+// mini : 2014-01-09 Bayerische Motoren Werke Aktiengesellschaft
+mini
+
+// mint : 2015-07-30 Intuit Administrative Services, Inc.
+mint
+
+// mit : 2015-07-02 Massachusetts Institute of Technology
+mit
+
+// mitsubishi : 2015-07-23 Mitsubishi Corporation
+mitsubishi
+
+// mlb : 2015-05-21 MLB Advanced Media DH, LLC
+mlb
+
+// mls : 2015-04-23 The Canadian Real Estate Association
+mls
+
+// mma : 2014-11-07 MMA IARD
+mma
+
+// mobile : 2016-06-02 Dish DBS Corporation
+mobile
+
+// mobily : 2014-12-18 GreenTech Consultancy Company W.L.L.
+mobily
+
+// moda : 2013-11-07 United TLD Holdco Ltd.
+moda
+
+// moe : 2013-11-13 Interlink Co., Ltd.
+moe
+
+// moi : 2014-12-18 Amazon Registry Services, Inc.
+moi
+
+// mom : 2015-04-16 Uniregistry, Corp.
+mom
+
+// monash : 2013-09-30 Monash University
+monash
+
+// money : 2014-10-16 Binky Moon, LLC
+money
+
+// monster : 2015-09-11 Monster Worldwide, Inc.
+monster
+
+// mopar : 2015-07-30 FCA US LLC.
+mopar
+
+// mormon : 2013-12-05 IRI Domain Management, LLC ("Applicant")
+mormon
+
+// mortgage : 2014-03-20 United TLD Holdco Ltd.
+mortgage
+
+// moscow : 2013-12-19 Foundation for Assistance for Internet Technologies and Infrastructure Development (FAITID)
+moscow
+
+// moto : 2015-06-04 Motorola Trademark Holdings, LLC
+moto
+
+// motorcycles : 2014-01-09 DERMotorcycles, LLC
+motorcycles
+
+// mov : 2014-01-30 Charleston Road Registry Inc.
+mov
+
+// movie : 2015-02-05 Binky Moon, LLC
+movie
+
+// movistar : 2014-10-16 Telefónica S.A.
+movistar
+
+// msd : 2015-07-23 MSD Registry Holdings, Inc.
+msd
+
+// mtn : 2014-12-04 MTN Dubai Limited
+mtn
+
+// mtr : 2015-03-12 MTR Corporation Limited
+mtr
+
+// mutual : 2015-04-02 Northwestern Mutual MU TLD Registry, LLC
+mutual
+
+// nab : 2015-08-20 National Australia Bank Limited
+nab
+
+// nadex : 2014-12-11 Nadex Domains, Inc.
+nadex
+
+// nagoya : 2013-10-24 GMO Registry, Inc.
+nagoya
+
+// nationwide : 2015-07-23 Nationwide Mutual Insurance Company
+nationwide
+
+// natura : 2015-03-12 NATURA COSMÉTICOS S.A.
+natura
+
+// navy : 2014-03-06 United TLD Holdco Ltd.
+navy
+
+// nba : 2015-07-31 NBA REGISTRY, LLC
+nba
+
+// nec : 2015-01-08 NEC Corporation
+nec
+
+// netbank : 2014-06-26 COMMONWEALTH BANK OF AUSTRALIA
+netbank
+
+// netflix : 2015-06-18 Netflix, Inc.
+netflix
+
+// network : 2013-11-14 Binky Moon, LLC
+network
+
+// neustar : 2013-12-05 Registry Services, LLC
+neustar
+
+// new : 2014-01-30 Charleston Road Registry Inc.
+new
+
+// newholland : 2015-09-03 CNH Industrial N.V.
+newholland
+
+// news : 2014-12-18 United TLD Holdco Ltd.
+news
+
+// next : 2015-06-18 Next plc
+next
+
+// nextdirect : 2015-06-18 Next plc
+nextdirect
+
+// nexus : 2014-07-24 Charleston Road Registry Inc.
+nexus
+
+// nfl : 2015-07-23 NFL Reg Ops LLC
+nfl
+
+// ngo : 2014-03-06 Public Interest Registry
+ngo
+
+// nhk : 2014-02-13 Japan Broadcasting Corporation (NHK)
+nhk
+
+// nico : 2014-12-04 DWANGO Co., Ltd.
+nico
+
+// nike : 2015-07-23 NIKE, Inc.
+nike
+
+// nikon : 2015-05-21 NIKON CORPORATION
+nikon
+
+// ninja : 2013-11-07 United TLD Holdco Ltd.
+ninja
+
+// nissan : 2014-03-27 NISSAN MOTOR CO., LTD.
+nissan
+
+// nissay : 2015-10-29 Nippon Life Insurance Company
+nissay
+
+// nokia : 2015-01-08 Nokia Corporation
+nokia
+
+// northwesternmutual : 2015-06-18 Northwestern Mutual Registry, LLC
+northwesternmutual
+
+// norton : 2014-12-04 Symantec Corporation
+norton
+
+// now : 2015-06-25 Amazon Registry Services, Inc.
+now
+
+// nowruz : 2014-09-04 Asia Green IT System Bilgisayar San. ve Tic. Ltd. Sti.
+nowruz
+
+// nowtv : 2015-05-14 Starbucks (HK) Limited
+nowtv
+
+// nra : 2014-05-22 NRA Holdings Company, INC.
+nra
+
+// nrw : 2013-11-21 Minds + Machines GmbH
+nrw
+
+// ntt : 2014-10-31 NIPPON TELEGRAPH AND TELEPHONE CORPORATION
+ntt
+
+// nyc : 2014-01-23 The City of New York by and through the New York City Department of Information Technology & Telecommunications
+nyc
+
+// obi : 2014-09-25 OBI Group Holding SE & Co. KGaA
+obi
+
+// observer : 2015-04-30 Top Level Spectrum, Inc.
+observer
+
+// off : 2015-07-23 Johnson Shareholdings, Inc.
+off
+
+// office : 2015-03-12 Microsoft Corporation
+office
+
+// okinawa : 2013-12-05 BRregistry, Inc.
+okinawa
+
+// olayan : 2015-05-14 Crescent Holding GmbH
+olayan
+
+// olayangroup : 2015-05-14 Crescent Holding GmbH
+olayangroup
+
+// oldnavy : 2015-07-31 The Gap, Inc.
+oldnavy
+
+// ollo : 2015-06-04 Dish DBS Corporation
+ollo
+
+// omega : 2015-01-08 The Swatch Group Ltd
+omega
+
+// one : 2014-11-07 One.com A/S
+one
+
+// ong : 2014-03-06 Public Interest Registry
+ong
+
+// onl : 2013-09-16 I-Registry Ltd.
+onl
+
+// online : 2015-01-15 DotOnline Inc.
+online
+
+// onyourside : 2015-07-23 Nationwide Mutual Insurance Company
+onyourside
+
+// ooo : 2014-01-09 INFIBEAM INCORPORATION LIMITED
+ooo
+
+// open : 2015-07-31 American Express Travel Related Services Company, Inc.
+open
+
+// oracle : 2014-06-19 Oracle Corporation
+oracle
+
+// orange : 2015-03-12 Orange Brand Services Limited
+orange
+
+// organic : 2014-03-27 Afilias plc
+organic
+
+// origins : 2015-10-01 The Estée Lauder Companies Inc.
+origins
+
+// osaka : 2014-09-04 Osaka Registry Co., Ltd.
+osaka
+
+// otsuka : 2013-10-11 Otsuka Holdings Co., Ltd.
+otsuka
+
+// ott : 2015-06-04 Dish DBS Corporation
+ott
+
+// ovh : 2014-01-16 OVH SAS
+ovh
+
+// page : 2014-12-04 Charleston Road Registry Inc.
+page
+
+// panasonic : 2015-07-30 Panasonic Corporation
+panasonic
+
+// paris : 2014-01-30 City of Paris
+paris
+
+// pars : 2014-09-04 Asia Green IT System Bilgisayar San. ve Tic. Ltd. Sti.
+pars
+
+// partners : 2013-12-05 Binky Moon, LLC
+partners
+
+// parts : 2013-12-05 Binky Moon, LLC
+parts
+
+// party : 2014-09-11 Blue Sky Registry Limited
+party
+
+// passagens : 2015-03-05 Travel Reservations SRL
+passagens
+
+// pay : 2015-08-27 Amazon Registry Services, Inc.
+pay
+
+// pccw : 2015-05-14 PCCW Enterprises Limited
+pccw
+
+// pet : 2015-05-07 Afilias plc
+pet
+
+// pfizer : 2015-09-11 Pfizer Inc.
+pfizer
+
+// pharmacy : 2014-06-19 National Association of Boards of Pharmacy
+pharmacy
+
+// phd : 2016-07-28 Charleston Road Registry Inc.
+phd
+
+// philips : 2014-11-07 Koninklijke Philips N.V.
+philips
+
+// phone : 2016-06-02 Dish DBS Corporation
+phone
+
+// photo : 2013-11-14 Uniregistry, Corp.
+photo
+
+// photography : 2013-09-20 Binky Moon, LLC
+photography
+
+// photos : 2013-10-17 Binky Moon, LLC
+photos
+
+// physio : 2014-05-01 PhysBiz Pty Ltd
+physio
+
+// piaget : 2014-10-16 Richemont DNS Inc.
+piaget
+
+// pics : 2013-11-14 Uniregistry, Corp.
+pics
+
+// pictet : 2014-06-26 Pictet Europe S.A.
+pictet
+
+// pictures : 2014-03-06 Binky Moon, LLC
+pictures
+
+// pid : 2015-01-08 Top Level Spectrum, Inc.
+pid
+
+// pin : 2014-12-18 Amazon Registry Services, Inc.
+pin
+
+// ping : 2015-06-11 Ping Registry Provider, Inc.
+ping
+
+// pink : 2013-10-01 Afilias plc
+pink
+
+// pioneer : 2015-07-16 Pioneer Corporation
+pioneer
+
+// pizza : 2014-06-26 Binky Moon, LLC
+pizza
+
+// place : 2014-04-24 Binky Moon, LLC
+place
+
+// play : 2015-03-05 Charleston Road Registry Inc.
+play
+
+// playstation : 2015-07-02 Sony Computer Entertainment Inc.
+playstation
+
+// plumbing : 2013-09-10 Binky Moon, LLC
+plumbing
+
+// plus : 2015-02-05 Binky Moon, LLC
+plus
+
+// pnc : 2015-07-02 PNC Domain Co., LLC
+pnc
+
+// pohl : 2014-06-23 Deutsche Vermögensberatung Aktiengesellschaft DVAG
+pohl
+
+// poker : 2014-07-03 Afilias plc
+poker
+
+// politie : 2015-08-20 Politie Nederland
+politie
+
+// porn : 2014-10-16 ICM Registry PN LLC
+porn
+
+// pramerica : 2015-07-30 Prudential Financial, Inc.
+pramerica
+
+// praxi : 2013-12-05 Praxi S.p.A.
+praxi
+
+// press : 2014-04-03 DotPress Inc.
+press
+
+// prime : 2015-06-25 Amazon Registry Services, Inc.
+prime
+
+// prod : 2014-01-23 Charleston Road Registry Inc.
+prod
+
+// productions : 2013-12-05 Binky Moon, LLC
+productions
+
+// prof : 2014-07-24 Charleston Road Registry Inc.
+prof
+
+// progressive : 2015-07-23 Progressive Casualty Insurance Company
+progressive
+
+// promo : 2014-12-18 Afilias plc
+promo
+
+// properties : 2013-12-05 Binky Moon, LLC
+properties
+
+// property : 2014-05-22 Uniregistry, Corp.
+property
+
+// protection : 2015-04-23 XYZ.COM LLC
+protection
+
+// pru : 2015-07-30 Prudential Financial, Inc.
+pru
+
+// prudential : 2015-07-30 Prudential Financial, Inc.
+prudential
+
+// pub : 2013-12-12 United TLD Holdco Ltd.
+pub
+
+// pwc : 2015-10-29 PricewaterhouseCoopers LLP
+pwc
+
+// qpon : 2013-11-14 dotCOOL, Inc.
+qpon
+
+// quebec : 2013-12-19 PointQuébec Inc
+quebec
+
+// quest : 2015-03-26 Quest ION Limited
+quest
+
+// qvc : 2015-07-30 QVC, Inc.
+qvc
+
+// racing : 2014-12-04 Premier Registry Limited
+racing
+
+// radio : 2016-07-21 European Broadcasting Union (EBU)
+radio
+
+// raid : 2015-07-23 Johnson Shareholdings, Inc.
+raid
+
+// read : 2014-12-18 Amazon Registry Services, Inc.
+read
+
+// realestate : 2015-09-11 dotRealEstate LLC
+realestate
+
+// realtor : 2014-05-29 Real Estate Domains LLC
+realtor
+
+// realty : 2015-03-19 Fegistry, LLC
+realty
+
+// recipes : 2013-10-17 Binky Moon, LLC
+recipes
+
+// red : 2013-11-07 Afilias plc
+red
+
+// redstone : 2014-10-31 Redstone Haute Couture Co., Ltd.
+redstone
+
+// redumbrella : 2015-03-26 Travelers TLD, LLC
+redumbrella
+
+// rehab : 2014-03-06 United TLD Holdco Ltd.
+rehab
+
+// reise : 2014-03-13 Binky Moon, LLC
+reise
+
+// reisen : 2014-03-06 Binky Moon, LLC
+reisen
+
+// reit : 2014-09-04 National Association of Real Estate Investment Trusts, Inc.
+reit
+
+// reliance : 2015-04-02 Reliance Industries Limited
+reliance
+
+// ren : 2013-12-12 Beijing Qianxiang Wangjing Technology Development Co., Ltd.
+ren
+
+// rent : 2014-12-04 XYZ.COM LLC
+rent
+
+// rentals : 2013-12-05 Binky Moon, LLC
+rentals
+
+// repair : 2013-11-07 Binky Moon, LLC
+repair
+
+// report : 2013-12-05 Binky Moon, LLC
+report
+
+// republican : 2014-03-20 United TLD Holdco Ltd.
+republican
+
+// rest : 2013-12-19 Punto 2012 Sociedad Anonima Promotora de Inversion de Capital Variable
+rest
+
+// restaurant : 2014-07-03 Binky Moon, LLC
+restaurant
+
+// review : 2014-11-20 dot Review Limited
+review
+
+// reviews : 2013-09-13 United TLD Holdco Ltd.
+reviews
+
+// rexroth : 2015-06-18 Robert Bosch GMBH
+rexroth
+
+// rich : 2013-11-21 I-Registry Ltd.
+rich
+
+// richardli : 2015-05-14 Pacific Century Asset Management (HK) Limited
+richardli
+
+// ricoh : 2014-11-20 Ricoh Company, Ltd.
+ricoh
+
+// rightathome : 2015-07-23 Johnson Shareholdings, Inc.
+rightathome
+
+// ril : 2015-04-02 Reliance Industries Limited
+ril
+
+// rio : 2014-02-27 Empresa Municipal de Informática SA - IPLANRIO
+rio
+
+// rip : 2014-07-10 United TLD Holdco Ltd.
+rip
+
+// rmit : 2015-11-19 Royal Melbourne Institute of Technology
+rmit
+
+// rocher : 2014-12-18 Ferrero Trading Lux S.A.
+rocher
+
+// rocks : 2013-11-14 United TLD Holdco Ltd.
+rocks
+
+// rodeo : 2013-12-19 Minds + Machines Group Limited
+rodeo
+
+// rogers : 2015-08-06 Rogers Communications Canada Inc.
+rogers
+
+// room : 2014-12-18 Amazon Registry Services, Inc.
+room
+
+// rsvp : 2014-05-08 Charleston Road Registry Inc.
+rsvp
+
+// rugby : 2016-12-15 World Rugby Strategic Developments Limited
+rugby
+
+// ruhr : 2013-10-02 regiodot GmbH & Co. KG
+ruhr
+
+// run : 2015-03-19 Binky Moon, LLC
+run
+
+// rwe : 2015-04-02 RWE AG
+rwe
+
+// ryukyu : 2014-01-09 BRregistry, Inc.
+ryukyu
+
+// saarland : 2013-12-12 dotSaarland GmbH
+saarland
+
+// safe : 2014-12-18 Amazon Registry Services, Inc.
+safe
+
+// safety : 2015-01-08 Safety Registry Services, LLC.
+safety
+
+// sakura : 2014-12-18 SAKURA Internet Inc.
+sakura
+
+// sale : 2014-10-16 United TLD Holdco Ltd.
+sale
+
+// salon : 2014-12-11 Binky Moon, LLC
+salon
+
+// samsclub : 2015-07-31 Wal-Mart Stores, Inc.
+samsclub
+
+// samsung : 2014-04-03 SAMSUNG SDS CO., LTD
+samsung
+
+// sandvik : 2014-11-13 Sandvik AB
+sandvik
+
+// sandvikcoromant : 2014-11-07 Sandvik AB
+sandvikcoromant
+
+// sanofi : 2014-10-09 Sanofi
+sanofi
+
+// sap : 2014-03-27 SAP AG
+sap
+
+// sarl : 2014-07-03 Binky Moon, LLC
+sarl
+
+// sas : 2015-04-02 Research IP LLC
+sas
+
+// save : 2015-06-25 Amazon Registry Services, Inc.
+save
+
+// saxo : 2014-10-31 Saxo Bank A/S
+saxo
+
+// sbi : 2015-03-12 STATE BANK OF INDIA
+sbi
+
+// sbs : 2014-11-07 SPECIAL BROADCASTING SERVICE CORPORATION
+sbs
+
+// sca : 2014-03-13 SVENSKA CELLULOSA AKTIEBOLAGET SCA (publ)
+sca
+
+// scb : 2014-02-20 The Siam Commercial Bank Public Company Limited ("SCB")
+scb
+
+// schaeffler : 2015-08-06 Schaeffler Technologies AG & Co. KG
+schaeffler
+
+// schmidt : 2014-04-03 SALM S.A.S.
+schmidt
+
+// scholarships : 2014-04-24 Scholarships.com, LLC
+scholarships
+
+// school : 2014-12-18 Binky Moon, LLC
+school
+
+// schule : 2014-03-06 Binky Moon, LLC
+schule
+
+// schwarz : 2014-09-18 Schwarz Domains und Services GmbH & Co. KG
+schwarz
+
+// science : 2014-09-11 dot Science Limited
+science
+
+// scjohnson : 2015-07-23 Johnson Shareholdings, Inc.
+scjohnson
+
+// scor : 2014-10-31 SCOR SE
+scor
+
+// scot : 2014-01-23 Dot Scot Registry Limited
+scot
+
+// search : 2016-06-09 Charleston Road Registry Inc.
+search
+
+// seat : 2014-05-22 SEAT, S.A. (Sociedad Unipersonal)
+seat
+
+// secure : 2015-08-27 Amazon Registry Services, Inc.
+secure
+
+// security : 2015-05-14 XYZ.COM LLC
+security
+
+// seek : 2014-12-04 Seek Limited
+seek
+
+// select : 2015-10-08 iSelect Ltd
+select
+
+// sener : 2014-10-24 Sener Ingeniería y Sistemas, S.A.
+sener
+
+// services : 2014-02-27 Binky Moon, LLC
+services
+
+// ses : 2015-07-23 SES
+ses
+
+// seven : 2015-08-06 Seven West Media Ltd
+seven
+
+// sew : 2014-07-17 SEW-EURODRIVE GmbH & Co KG
+sew
+
+// sex : 2014-11-13 ICM Registry SX LLC
+sex
+
+// sexy : 2013-09-11 Uniregistry, Corp.
+sexy
+
+// sfr : 2015-08-13 Societe Francaise du Radiotelephone - SFR
+sfr
+
+// shangrila : 2015-09-03 Shangri‐La International Hotel Management Limited
+shangrila
+
+// sharp : 2014-05-01 Sharp Corporation
+sharp
+
+// shaw : 2015-04-23 Shaw Cablesystems G.P.
+shaw
+
+// shell : 2015-07-30 Shell Information Technology International Inc
+shell
+
+// shia : 2014-09-04 Asia Green IT System Bilgisayar San. ve Tic. Ltd. Sti.
+shia
+
+// shiksha : 2013-11-14 Afilias plc
+shiksha
+
+// shoes : 2013-10-02 Binky Moon, LLC
+shoes
+
+// shop : 2016-04-08 GMO Registry, Inc.
+shop
+
+// shopping : 2016-03-31 Binky Moon, LLC
+shopping
+
+// shouji : 2015-01-08 QIHOO 360 TECHNOLOGY CO. LTD.
+shouji
+
+// show : 2015-03-05 Binky Moon, LLC
+show
+
+// showtime : 2015-08-06 CBS Domains Inc.
+showtime
+
+// shriram : 2014-01-23 Shriram Capital Ltd.
+shriram
+
+// silk : 2015-06-25 Amazon Registry Services, Inc.
+silk
+
+// sina : 2015-03-12 Sina Corporation
+sina
+
+// singles : 2013-08-27 Binky Moon, LLC
+singles
+
+// site : 2015-01-15 DotSite Inc.
+site
+
+// ski : 2015-04-09 Afilias plc
+ski
+
+// skin : 2015-01-15 L'Oréal
+skin
+
+// sky : 2014-06-19 Sky International AG
+sky
+
+// skype : 2014-12-18 Microsoft Corporation
+skype
+
+// sling : 2015-07-30 Hughes Satellite Systems Corporation
+sling
+
+// smart : 2015-07-09 Smart Communications, Inc. (SMART)
+smart
+
+// smile : 2014-12-18 Amazon Registry Services, Inc.
+smile
+
+// sncf : 2015-02-19 Société Nationale des Chemins de fer Francais S N C F
+sncf
+
+// soccer : 2015-03-26 Binky Moon, LLC
+soccer
+
+// social : 2013-11-07 United TLD Holdco Ltd.
+social
+
+// softbank : 2015-07-02 SoftBank Corp.
+softbank
+
+// software : 2014-03-20 United TLD Holdco Ltd.
+software
+
+// sohu : 2013-12-19 Sohu.com Limited
+sohu
+
+// solar : 2013-11-07 Binky Moon, LLC
+solar
+
+// solutions : 2013-11-07 Binky Moon, LLC
+solutions
+
+// song : 2015-02-26 Amazon Registry Services, Inc.
+song
+
+// sony : 2015-01-08 Sony Corporation
+sony
+
+// soy : 2014-01-23 Charleston Road Registry Inc.
+soy
+
+// space : 2014-04-03 DotSpace Inc.
+space
+
+// sport : 2017-11-16 Global Association of International Sports Federations (GAISF)
+sport
+
+// spot : 2015-02-26 Amazon Registry Services, Inc.
+spot
+
+// spreadbetting : 2014-12-11 Dotspreadbetting Registry Limited
+spreadbetting
+
+// srl : 2015-05-07 InterNetX, Corp
+srl
+
+// srt : 2015-07-30 FCA US LLC.
+srt
+
+// stada : 2014-11-13 STADA Arzneimittel AG
+stada
+
+// staples : 2015-07-30 Staples, Inc.
+staples
+
+// star : 2015-01-08 Star India Private Limited
+star
+
+// starhub : 2015-02-05 StarHub Ltd
+starhub
+
+// statebank : 2015-03-12 STATE BANK OF INDIA
+statebank
+
+// statefarm : 2015-07-30 State Farm Mutual Automobile Insurance Company
+statefarm
+
+// stc : 2014-10-09 Saudi Telecom Company
+stc
+
+// stcgroup : 2014-10-09 Saudi Telecom Company
+stcgroup
+
+// stockholm : 2014-12-18 Stockholms kommun
+stockholm
+
+// storage : 2014-12-22 XYZ.COM LLC
+storage
+
+// store : 2015-04-09 DotStore Inc.
+store
+
+// stream : 2016-01-08 dot Stream Limited
+stream
+
+// studio : 2015-02-11 United TLD Holdco Ltd.
+studio
+
+// study : 2014-12-11 OPEN UNIVERSITIES AUSTRALIA PTY LTD
+study
+
+// style : 2014-12-04 Binky Moon, LLC
+style
+
+// sucks : 2014-12-22 Vox Populi Registry Ltd.
+sucks
+
+// supplies : 2013-12-19 Binky Moon, LLC
+supplies
+
+// supply : 2013-12-19 Binky Moon, LLC
+supply
+
+// support : 2013-10-24 Binky Moon, LLC
+support
+
+// surf : 2014-01-09 Minds + Machines Group Limited
+surf
+
+// surgery : 2014-03-20 Binky Moon, LLC
+surgery
+
+// suzuki : 2014-02-20 SUZUKI MOTOR CORPORATION
+suzuki
+
+// swatch : 2015-01-08 The Swatch Group Ltd
+swatch
+
+// swiftcover : 2015-07-23 Swiftcover Insurance Services Limited
+swiftcover
+
+// swiss : 2014-10-16 Swiss Confederation
+swiss
+
+// sydney : 2014-09-18 State of New South Wales, Department of Premier and Cabinet
+sydney
+
+// symantec : 2014-12-04 Symantec Corporation
+symantec
+
+// systems : 2013-11-07 Binky Moon, LLC
+systems
+
+// tab : 2014-12-04 Tabcorp Holdings Limited
+tab
+
+// taipei : 2014-07-10 Taipei City Government
+taipei
+
+// talk : 2015-04-09 Amazon Registry Services, Inc.
+talk
+
+// taobao : 2015-01-15 Alibaba Group Holding Limited
+taobao
+
+// target : 2015-07-31 Target Domain Holdings, LLC
+target
+
+// tatamotors : 2015-03-12 Tata Motors Ltd
+tatamotors
+
+// tatar : 2014-04-24 Limited Liability Company "Coordination Center of Regional Domain of Tatarstan Republic"
+tatar
+
+// tattoo : 2013-08-30 Uniregistry, Corp.
+tattoo
+
+// tax : 2014-03-20 Binky Moon, LLC
+tax
+
+// taxi : 2015-03-19 Binky Moon, LLC
+taxi
+
+// tci : 2014-09-12 Asia Green IT System Bilgisayar San. ve Tic. Ltd. Sti.
+tci
+
+// tdk : 2015-06-11 TDK Corporation
+tdk
+
+// team : 2015-03-05 Binky Moon, LLC
+team
+
+// tech : 2015-01-30 Personals TLD Inc.
+tech
+
+// technology : 2013-09-13 Binky Moon, LLC
+technology
+
+// telefonica : 2014-10-16 Telefónica S.A.
+telefonica
+
+// temasek : 2014-08-07 Temasek Holdings (Private) Limited
+temasek
+
+// tennis : 2014-12-04 Binky Moon, LLC
+tennis
+
+// teva : 2015-07-02 Teva Pharmaceutical Industries Limited
+teva
+
+// thd : 2015-04-02 Home Depot Product Authority, LLC
+thd
+
+// theater : 2015-03-19 Binky Moon, LLC
+theater
+
+// theatre : 2015-05-07 XYZ.COM LLC
+theatre
+
+// tiaa : 2015-07-23 Teachers Insurance and Annuity Association of America
+tiaa
+
+// tickets : 2015-02-05 Accent Media Limited
+tickets
+
+// tienda : 2013-11-14 Binky Moon, LLC
+tienda
+
+// tiffany : 2015-01-30 Tiffany and Company
+tiffany
+
+// tips : 2013-09-20 Binky Moon, LLC
+tips
+
+// tires : 2014-11-07 Binky Moon, LLC
+tires
+
+// tirol : 2014-04-24 punkt Tirol GmbH
+tirol
+
+// tjmaxx : 2015-07-16 The TJX Companies, Inc.
+tjmaxx
+
+// tjx : 2015-07-16 The TJX Companies, Inc.
+tjx
+
+// tkmaxx : 2015-07-16 The TJX Companies, Inc.
+tkmaxx
+
+// tmall : 2015-01-15 Alibaba Group Holding Limited
+tmall
+
+// today : 2013-09-20 Binky Moon, LLC
+today
+
+// tokyo : 2013-11-13 GMO Registry, Inc.
+tokyo
+
+// tools : 2013-11-21 Binky Moon, LLC
+tools
+
+// top : 2014-03-20 .TOP Registry
+top
+
+// toray : 2014-12-18 Toray Industries, Inc.
+toray
+
+// toshiba : 2014-04-10 TOSHIBA Corporation
+toshiba
+
+// total : 2015-08-06 Total SA
+total
+
+// tours : 2015-01-22 Binky Moon, LLC
+tours
+
+// town : 2014-03-06 Binky Moon, LLC
+town
+
+// toyota : 2015-04-23 TOYOTA MOTOR CORPORATION
+toyota
+
+// toys : 2014-03-06 Binky Moon, LLC
+toys
+
+// trade : 2014-01-23 Elite Registry Limited
+trade
+
+// trading : 2014-12-11 Dottrading Registry Limited
+trading
+
+// training : 2013-11-07 Binky Moon, LLC
+training
+
+// travel :  Dog Beach, LLC
+travel
+
+// travelchannel : 2015-07-02 Lifestyle Domain Holdings, Inc.
+travelchannel
+
+// travelers : 2015-03-26 Travelers TLD, LLC
+travelers
+
+// travelersinsurance : 2015-03-26 Travelers TLD, LLC
+travelersinsurance
+
+// trust : 2014-10-16 NCC Group Inc.
+trust
+
+// trv : 2015-03-26 Travelers TLD, LLC
+trv
+
+// tube : 2015-06-11 Latin American Telecom LLC
+tube
+
+// tui : 2014-07-03 TUI AG
+tui
+
+// tunes : 2015-02-26 Amazon Registry Services, Inc.
+tunes
+
+// tushu : 2014-12-18 Amazon Registry Services, Inc.
+tushu
+
+// tvs : 2015-02-19 T V SUNDRAM IYENGAR  & SONS LIMITED
+tvs
+
+// ubank : 2015-08-20 National Australia Bank Limited
+ubank
+
+// ubs : 2014-12-11 UBS AG
+ubs
+
+// uconnect : 2015-07-30 FCA US LLC.
+uconnect
+
+// unicom : 2015-10-15 China United Network Communications Corporation Limited
+unicom
+
+// university : 2014-03-06 Binky Moon, LLC
+university
+
+// uno : 2013-09-11 Dot Latin LLC
+uno
+
+// uol : 2014-05-01 UBN INTERNET LTDA.
+uol
+
+// ups : 2015-06-25 UPS Market Driver, Inc.
+ups
+
+// vacations : 2013-12-05 Binky Moon, LLC
+vacations
+
+// vana : 2014-12-11 Lifestyle Domain Holdings, Inc.
+vana
+
+// vanguard : 2015-09-03 The Vanguard Group, Inc.
+vanguard
+
+// vegas : 2014-01-16 Dot Vegas, Inc.
+vegas
+
+// ventures : 2013-08-27 Binky Moon, LLC
+ventures
+
+// verisign : 2015-08-13 VeriSign, Inc.
+verisign
+
+// versicherung : 2014-03-20 TLD-BOX Registrydienstleistungen GmbH
+versicherung
+
+// vet : 2014-03-06 United TLD Holdco Ltd.
+vet
+
+// viajes : 2013-10-17 Binky Moon, LLC
+viajes
+
+// video : 2014-10-16 United TLD Holdco Ltd.
+video
+
+// vig : 2015-05-14 VIENNA INSURANCE GROUP AG Wiener Versicherung Gruppe
+vig
+
+// viking : 2015-04-02 Viking River Cruises (Bermuda) Ltd.
+viking
+
+// villas : 2013-12-05 Binky Moon, LLC
+villas
+
+// vin : 2015-06-18 Binky Moon, LLC
+vin
+
+// vip : 2015-01-22 Minds + Machines Group Limited
+vip
+
+// virgin : 2014-09-25 Virgin Enterprises Limited
+virgin
+
+// visa : 2015-07-30 Visa Worldwide Pte. Limited
+visa
+
+// vision : 2013-12-05 Binky Moon, LLC
+vision
+
+// vistaprint : 2014-09-18 Vistaprint Limited
+vistaprint
+
+// viva : 2014-11-07 Saudi Telecom Company
+viva
+
+// vivo : 2015-07-31 Telefonica Brasil S.A.
+vivo
+
+// vlaanderen : 2014-02-06 DNS.be vzw
+vlaanderen
+
+// vodka : 2013-12-19 Minds + Machines Group Limited
+vodka
+
+// volkswagen : 2015-05-14 Volkswagen Group of America Inc.
+volkswagen
+
+// volvo : 2015-11-12 Volvo Holding Sverige Aktiebolag
+volvo
+
+// vote : 2013-11-21 Monolith Registry LLC
+vote
+
+// voting : 2013-11-13 Valuetainment Corp.
+voting
+
+// voto : 2013-11-21 Monolith Registry LLC
+voto
+
+// voyage : 2013-08-27 Binky Moon, LLC
+voyage
+
+// vuelos : 2015-03-05 Travel Reservations SRL
+vuelos
+
+// wales : 2014-05-08 Nominet UK
+wales
+
+// walmart : 2015-07-31 Wal-Mart Stores, Inc.
+walmart
+
+// walter : 2014-11-13 Sandvik AB
+walter
+
+// wang : 2013-10-24 Zodiac Wang Limited
+wang
+
+// wanggou : 2014-12-18 Amazon Registry Services, Inc.
+wanggou
+
+// warman : 2015-06-18 Weir Group IP Limited
+warman
+
+// watch : 2013-11-14 Binky Moon, LLC
+watch
+
+// watches : 2014-12-22 Richemont DNS Inc.
+watches
+
+// weather : 2015-01-08 International Business Machines Corporation
+weather
+
+// weatherchannel : 2015-03-12 International Business Machines Corporation
+weatherchannel
+
+// webcam : 2014-01-23 dot Webcam Limited
+webcam
+
+// weber : 2015-06-04 Saint-Gobain Weber SA
+weber
+
+// website : 2014-04-03 DotWebsite Inc.
+website
+
+// wed : 2013-10-01 Atgron, Inc.
+wed
+
+// wedding : 2014-04-24 Minds + Machines Group Limited
+wedding
+
+// weibo : 2015-03-05 Sina Corporation
+weibo
+
+// weir : 2015-01-29 Weir Group IP Limited
+weir
+
+// whoswho : 2014-02-20 Who's Who Registry
+whoswho
+
+// wien : 2013-10-28 punkt.wien GmbH
+wien
+
+// wiki : 2013-11-07 Top Level Design, LLC
+wiki
+
+// williamhill : 2014-03-13 William Hill Organization Limited
+williamhill
+
+// win : 2014-11-20 First Registry Limited
+win
+
+// windows : 2014-12-18 Microsoft Corporation
+windows
+
+// wine : 2015-06-18 Binky Moon, LLC
+wine
+
+// winners : 2015-07-16 The TJX Companies, Inc.
+winners
+
+// wme : 2014-02-13 William Morris Endeavor Entertainment, LLC
+wme
+
+// wolterskluwer : 2015-08-06 Wolters Kluwer N.V.
+wolterskluwer
+
+// woodside : 2015-07-09 Woodside Petroleum Limited
+woodside
+
+// work : 2013-12-19 Minds + Machines Group Limited
+work
+
+// works : 2013-11-14 Binky Moon, LLC
+works
+
+// world : 2014-06-12 Binky Moon, LLC
+world
+
+// wow : 2015-10-08 Amazon Registry Services, Inc.
+wow
+
+// wtc : 2013-12-19 World Trade Centers Association, Inc.
+wtc
+
+// wtf : 2014-03-06 Binky Moon, LLC
+wtf
+
+// xbox : 2014-12-18 Microsoft Corporation
+xbox
+
+// xerox : 2014-10-24 Xerox DNHC LLC
+xerox
+
+// xfinity : 2015-07-09 Comcast IP Holdings I, LLC
+xfinity
+
+// xihuan : 2015-01-08 QIHOO 360 TECHNOLOGY CO. LTD.
+xihuan
+
+// xin : 2014-12-11 Elegant Leader Limited
+xin
+
+// xn--11b4c3d : 2015-01-15 VeriSign Sarl
+कॉम
+
+// xn--1ck2e1b : 2015-02-26 Amazon Registry Services, Inc.
+セール
+
+// xn--1qqw23a : 2014-01-09 Guangzhou YU Wei Information Technology Co., Ltd.
+佛山
+
+// xn--30rr7y : 2014-06-12 Excellent First Limited
+慈善
+
+// xn--3bst00m : 2013-09-13 Eagle Horizon Limited
+集团
+
+// xn--3ds443g : 2013-09-08 TLD REGISTRY LIMITED
+在线
+
+// xn--3oq18vl8pn36a : 2015-07-02 Volkswagen (China) Investment Co., Ltd.
+大众汽车
+
+// xn--3pxu8k : 2015-01-15 VeriSign Sarl
+点看
+
+// xn--42c2d9a : 2015-01-15 VeriSign Sarl
+คอม
+
+// xn--45q11c : 2013-11-21 Zodiac Gemini Ltd
+八卦
+
+// xn--4gbrim : 2013-10-04 Suhub Electronic Establishment
+موقع
+
+// xn--55qw42g : 2013-11-08 China Organizational Name Administration Center
+公益
+
+// xn--55qx5d : 2013-11-14 China Internet Network Information Center (CNNIC)
+公司
+
+// xn--5su34j936bgsg : 2015-09-03 Shangri‐La International Hotel Management Limited
+香格里拉
+
+// xn--5tzm5g : 2014-12-22 Global Website TLD Asia Limited
+网站
+
+// xn--6frz82g : 2013-09-23 Afilias plc
+移动
+
+// xn--6qq986b3xl : 2013-09-13 Tycoon Treasure Limited
+我爱你
+
+// xn--80adxhks : 2013-12-19 Foundation for Assistance for Internet Technologies and Infrastructure Development (FAITID)
+москва
+
+// xn--80aqecdr1a : 2015-10-21 Pontificium Consilium de Comunicationibus Socialibus (PCCS) (Pontifical Council for Social Communication)
+католик
+
+// xn--80asehdb : 2013-07-14 CORE Association
+онлайн
+
+// xn--80aswg : 2013-07-14 CORE Association
+сайт
+
+// xn--8y0a063a : 2015-03-26 China United Network Communications Corporation Limited
+联通
+
+// xn--9dbq2a : 2015-01-15 VeriSign Sarl
+קום
+
+// xn--9et52u : 2014-06-12 RISE VICTORY LIMITED
+时尚
+
+// xn--9krt00a : 2015-03-12 Sina Corporation
+微博
+
+// xn--b4w605ferd : 2014-08-07 Temasek Holdings (Private) Limited
+淡马锡
+
+// xn--bck1b9a5dre4c : 2015-02-26 Amazon Registry Services, Inc.
+ファッション
+
+// xn--c1avg : 2013-11-14 Public Interest Registry
+орг
+
+// xn--c2br7g : 2015-01-15 VeriSign Sarl
+नेट
+
+// xn--cck2b3b : 2015-02-26 Amazon Registry Services, Inc.
+ストア
+
+// xn--cg4bki : 2013-09-27 SAMSUNG SDS CO., LTD
+삼성
+
+// xn--czr694b : 2014-01-16 Dot Trademark TLD Holding Company Limited
+商标
+
+// xn--czrs0t : 2013-12-19 Binky Moon, LLC
+商店
+
+// xn--czru2d : 2013-11-21 Zodiac Aquarius Limited
+商城
+
+// xn--d1acj3b : 2013-11-20 The Foundation for Network Initiatives “The Smart Internet”
+дети
+
+// xn--eckvdtc9d : 2014-12-18 Amazon Registry Services, Inc.
+ポイント
+
+// xn--efvy88h : 2014-08-22 Guangzhou YU Wei Information Technology Co., Ltd.
+新闻
+
+// xn--estv75g : 2015-02-19 Industrial and Commercial Bank of China Limited
+工行
+
+// xn--fct429k : 2015-04-09 Amazon Registry Services, Inc.
+家電
+
+// xn--fhbei : 2015-01-15 VeriSign Sarl
+كوم
+
+// xn--fiq228c5hs : 2013-09-08 TLD REGISTRY LIMITED
+中文网
+
+// xn--fiq64b : 2013-10-14 CITIC Group Corporation
+中信
+
+// xn--fjq720a : 2014-05-22 Binky Moon, LLC
+娱乐
+
+// xn--flw351e : 2014-07-31 Charleston Road Registry Inc.
+谷歌
+
+// xn--fzys8d69uvgm : 2015-05-14 PCCW Enterprises Limited
+電訊盈科
+
+// xn--g2xx48c : 2015-01-30 Minds + Machines Group Limited
+购物
+
+// xn--gckr3f0f : 2015-02-26 Amazon Registry Services, Inc.
+クラウド
+
+// xn--gk3at1e : 2015-10-08 Amazon Registry Services, Inc.
+通販
+
+// xn--hxt814e : 2014-05-15 Zodiac Taurus Limited
+网店
+
+// xn--i1b6b1a6a2e : 2013-11-14 Public Interest Registry
+संगठन
+
+// xn--imr513n : 2014-12-11 Dot Trademark TLD Holding Company Limited
+餐厅
+
+// xn--io0a7i : 2013-11-14 China Internet Network Information Center (CNNIC)
+网络
+
+// xn--j1aef : 2015-01-15 VeriSign Sarl
+ком
+
+// xn--jlq61u9w7b : 2015-01-08 Nokia Corporation
+诺基亚
+
+// xn--jvr189m : 2015-02-26 Amazon Registry Services, Inc.
+食品
+
+// xn--kcrx77d1x4a : 2014-11-07 Koninklijke Philips N.V.
+飞利浦
+
+// xn--kpu716f : 2014-12-22 Richemont DNS Inc.
+手表
+
+// xn--kput3i : 2014-02-13 Beijing RITT-Net Technology Development Co., Ltd
+手机
+
+// xn--mgba3a3ejt : 2014-11-20 Aramco Services Company
+ارامكو
+
+// xn--mgba7c0bbn0a : 2015-05-14 Crescent Holding GmbH
+العليان
+
+// xn--mgbaakc7dvf : 2015-09-03 Emirates Telecommunications Corporation (trading as Etisalat)
+اتصالات
+
+// xn--mgbab2bd : 2013-10-31 CORE Association
+بازار
+
+// xn--mgbb9fbpob : 2014-12-18 GreenTech Consultancy Company W.L.L.
+موبايلي
+
+// xn--mgbca7dzdo : 2015-07-30 Abu Dhabi Systems and Information Centre
+ابوظبي
+
+// xn--mgbi4ecexp : 2015-10-21 Pontificium Consilium de Comunicationibus Socialibus (PCCS) (Pontifical Council for Social Communication)
+كاثوليك
+
+// xn--mgbt3dhd : 2014-09-04 Asia Green IT System Bilgisayar San. ve Tic. Ltd. Sti.
+همراه
+
+// xn--mk1bu44c : 2015-01-15 VeriSign Sarl
+닷컴
+
+// xn--mxtq1m : 2014-03-06 Net-Chinese Co., Ltd.
+政府
+
+// xn--ngbc5azd : 2013-07-13 International Domain Registry Pty. Ltd.
+شبكة
+
+// xn--ngbe9e0a : 2014-12-04 Kuwait Finance House
+بيتك
+
+// xn--ngbrx : 2015-11-12 League of Arab States
+عرب
+
+// xn--nqv7f : 2013-11-14 Public Interest Registry
+机构
+
+// xn--nqv7fs00ema : 2013-11-14 Public Interest Registry
+组织机构
+
+// xn--nyqy26a : 2014-11-07 Stable Tone Limited
+健康
+
+// xn--otu796d : 2017-08-06 Dot Trademark TLD Holding Company Limited
+招聘
+
+// xn--p1acf : 2013-12-12 Rusnames Limited
+рус
+
+// xn--pbt977c : 2014-12-22 Richemont DNS Inc.
+珠宝
+
+// xn--pssy2u : 2015-01-15 VeriSign Sarl
+大拿
+
+// xn--q9jyb4c : 2013-09-17 Charleston Road Registry Inc.
+みんな
+
+// xn--qcka1pmc : 2014-07-31 Charleston Road Registry Inc.
+グーグル
+
+// xn--rhqv96g : 2013-09-11 Stable Tone Limited
+世界
+
+// xn--rovu88b : 2015-02-26 Amazon Registry Services, Inc.
+書籍
+
+// xn--ses554g : 2014-01-16 KNET Co., Ltd.
+网址
+
+// xn--t60b56a : 2015-01-15 VeriSign Sarl
+닷넷
+
+// xn--tckwe : 2015-01-15 VeriSign Sarl
+コム
+
+// xn--tiq49xqyj : 2015-10-21 Pontificium Consilium de Comunicationibus Socialibus (PCCS) (Pontifical Council for Social Communication)
+天主教
+
+// xn--unup4y : 2013-07-14 Binky Moon, LLC
+游戏
+
+// xn--vermgensberater-ctb : 2014-06-23 Deutsche Vermögensberatung Aktiengesellschaft DVAG
+vermögensberater
+
+// xn--vermgensberatung-pwb : 2014-06-23 Deutsche Vermögensberatung Aktiengesellschaft DVAG
+vermögensberatung
+
+// xn--vhquv : 2013-08-27 Binky Moon, LLC
+企业
+
+// xn--vuq861b : 2014-10-16 Beijing Tele-info Network Technology Co., Ltd.
+信息
+
+// xn--w4r85el8fhu5dnra : 2015-04-30 Kerry Trading Co. Limited
+嘉里大酒店
+
+// xn--w4rs40l : 2015-07-30 Kerry Trading Co. Limited
+嘉里
+
+// xn--xhq521b : 2013-11-14 Guangzhou YU Wei Information Technology Co., Ltd.
+广东
+
+// xn--zfr164b : 2013-11-08 China Organizational Name Administration Center
+政务
+
+// xyz : 2013-12-05 XYZ.COM LLC
+xyz
+
+// yachts : 2014-01-09 DERYachts, LLC
+yachts
+
+// yahoo : 2015-04-02 Yahoo! Domain Services Inc.
+yahoo
+
+// yamaxun : 2014-12-18 Amazon Registry Services, Inc.
+yamaxun
+
+// yandex : 2014-04-10 YANDEX, LLC
+yandex
+
+// yodobashi : 2014-11-20 YODOBASHI CAMERA CO.,LTD.
+yodobashi
+
+// yoga : 2014-05-29 Minds + Machines Group Limited
+yoga
+
+// yokohama : 2013-12-12 GMO Registry, Inc.
+yokohama
+
+// you : 2015-04-09 Amazon Registry Services, Inc.
+you
+
+// youtube : 2014-05-01 Charleston Road Registry Inc.
+youtube
+
+// yun : 2015-01-08 QIHOO 360 TECHNOLOGY CO. LTD.
+yun
+
+// zappos : 2015-06-25 Amazon Registry Services, Inc.
+zappos
+
+// zara : 2014-11-07 Industria de Diseño Textil, S.A. (INDITEX, S.A.)
+zara
+
+// zero : 2014-12-18 Amazon Registry Services, Inc.
+zero
+
+// zip : 2014-05-08 Charleston Road Registry Inc.
+zip
+
+// zone : 2013-11-14 Binky Moon, LLC
+zone
+
+// zuerich : 2014-11-07 Kanton Zürich (Canton of Zurich)
+zuerich
+
+
+// ===END ICANN DOMAINS===
+// ===BEGIN PRIVATE DOMAINS===
+// (Note: these are in alphabetical order by company name)
+
+// 1GB LLC : https://www.1gb.ua/
+// Submitted by 1GB LLC <noc@1gb.com.ua>
+cc.ua
+inf.ua
+ltd.ua
+
+// Agnat sp. z o.o. : https://domena.pl
+// Submitted by Przemyslaw Plewa <it-admin@domena.pl>
+beep.pl
+
+// Alces Software Ltd : http://alces-software.com
+// Submitted by Mark J. Titorenko <mark.titorenko@alces-software.com>
+*.compute.estate
+*.alces.network
+
+// alwaysdata : https://www.alwaysdata.com
+// Submitted by Cyril <admin@alwaysdata.com>
+alwaysdata.net
+
+// Amazon CloudFront : https://aws.amazon.com/cloudfront/
+// Submitted by Donavan Miller <donavanm@amazon.com>
+cloudfront.net
+
+// Amazon Elastic Compute Cloud : https://aws.amazon.com/ec2/
+// Submitted by Luke Wells <psl-maintainers@amazon.com>
+*.compute.amazonaws.com
+*.compute-1.amazonaws.com
+*.compute.amazonaws.com.cn
+us-east-1.amazonaws.com
+
+// Amazon Elastic Beanstalk : https://aws.amazon.com/elasticbeanstalk/
+// Submitted by Luke Wells <psl-maintainers@amazon.com>
+cn-north-1.eb.amazonaws.com.cn
+cn-northwest-1.eb.amazonaws.com.cn
+elasticbeanstalk.com
+ap-northeast-1.elasticbeanstalk.com
+ap-northeast-2.elasticbeanstalk.com
+ap-northeast-3.elasticbeanstalk.com
+ap-south-1.elasticbeanstalk.com
+ap-southeast-1.elasticbeanstalk.com
+ap-southeast-2.elasticbeanstalk.com
+ca-central-1.elasticbeanstalk.com
+eu-central-1.elasticbeanstalk.com
+eu-west-1.elasticbeanstalk.com
+eu-west-2.elasticbeanstalk.com
+eu-west-3.elasticbeanstalk.com
+sa-east-1.elasticbeanstalk.com
+us-east-1.elasticbeanstalk.com
+us-east-2.elasticbeanstalk.com
+us-gov-west-1.elasticbeanstalk.com
+us-west-1.elasticbeanstalk.com
+us-west-2.elasticbeanstalk.com
+
+// Amazon Elastic Load Balancing : https://aws.amazon.com/elasticloadbalancing/
+// Submitted by Luke Wells <psl-maintainers@amazon.com>
+*.elb.amazonaws.com
+*.elb.amazonaws.com.cn
+
+// Amazon S3 : https://aws.amazon.com/s3/
+// Submitted by Luke Wells <psl-maintainers@amazon.com>
+s3.amazonaws.com
+s3-ap-northeast-1.amazonaws.com
+s3-ap-northeast-2.amazonaws.com
+s3-ap-south-1.amazonaws.com
+s3-ap-southeast-1.amazonaws.com
+s3-ap-southeast-2.amazonaws.com
+s3-ca-central-1.amazonaws.com
+s3-eu-central-1.amazonaws.com
+s3-eu-west-1.amazonaws.com
+s3-eu-west-2.amazonaws.com
+s3-eu-west-3.amazonaws.com
+s3-external-1.amazonaws.com
+s3-fips-us-gov-west-1.amazonaws.com
+s3-sa-east-1.amazonaws.com
+s3-us-gov-west-1.amazonaws.com
+s3-us-east-2.amazonaws.com
+s3-us-west-1.amazonaws.com
+s3-us-west-2.amazonaws.com
+s3.ap-northeast-2.amazonaws.com
+s3.ap-south-1.amazonaws.com
+s3.cn-north-1.amazonaws.com.cn
+s3.ca-central-1.amazonaws.com
+s3.eu-central-1.amazonaws.com
+s3.eu-west-2.amazonaws.com
+s3.eu-west-3.amazonaws.com
+s3.us-east-2.amazonaws.com
+s3.dualstack.ap-northeast-1.amazonaws.com
+s3.dualstack.ap-northeast-2.amazonaws.com
+s3.dualstack.ap-south-1.amazonaws.com
+s3.dualstack.ap-southeast-1.amazonaws.com
+s3.dualstack.ap-southeast-2.amazonaws.com
+s3.dualstack.ca-central-1.amazonaws.com
+s3.dualstack.eu-central-1.amazonaws.com
+s3.dualstack.eu-west-1.amazonaws.com
+s3.dualstack.eu-west-2.amazonaws.com
+s3.dualstack.eu-west-3.amazonaws.com
+s3.dualstack.sa-east-1.amazonaws.com
+s3.dualstack.us-east-1.amazonaws.com
+s3.dualstack.us-east-2.amazonaws.com
+s3-website-us-east-1.amazonaws.com
+s3-website-us-west-1.amazonaws.com
+s3-website-us-west-2.amazonaws.com
+s3-website-ap-northeast-1.amazonaws.com
+s3-website-ap-southeast-1.amazonaws.com
+s3-website-ap-southeast-2.amazonaws.com
+s3-website-eu-west-1.amazonaws.com
+s3-website-sa-east-1.amazonaws.com
+s3-website.ap-northeast-2.amazonaws.com
+s3-website.ap-south-1.amazonaws.com
+s3-website.ca-central-1.amazonaws.com
+s3-website.eu-central-1.amazonaws.com
+s3-website.eu-west-2.amazonaws.com
+s3-website.eu-west-3.amazonaws.com
+s3-website.us-east-2.amazonaws.com
+
+// Amune : https://amune.org/
+// Submitted by Team Amune <cert@amune.org>
+t3l3p0rt.net
+tele.amune.org
+
+// Apigee : https://apigee.com/
+// Submitted by Apigee Security Team <security@apigee.com>
+apigee.io
+
+// Aptible : https://www.aptible.com/
+// Submitted by Thomas Orozco <thomas@aptible.com>
+on-aptible.com
+
+// Asociación Amigos de la Informática "Euskalamiga" : http://encounter.eus/
+// Submitted by Hector Martin <marcan@euskalencounter.org>
+user.party.eus
+
+// Association potager.org : https://potager.org/
+// Submitted by Lunar <jardiniers@potager.org>
+pimienta.org
+poivron.org
+potager.org
+sweetpepper.org
+
+// ASUSTOR Inc. : http://www.asustor.com
+// Submitted by Vincent Tseng <vincenttseng@asustor.com>
+myasustor.com
+
+// Automattic Inc. : https://automattic.com/
+// Submitted by Alex Concha <alex.concha@automattic.com>
+go-vip.co
+wpcomstaging.com
+
+// AVM : https://avm.de
+// Submitted by Andreas Weise <a.weise@avm.de>
+myfritz.net
+
+// AW AdvisorWebsites.com Software Inc : https://advisorwebsites.com
+// Submitted by James Kennedy <domains@advisorwebsites.com>
+*.awdev.ca
+*.advisor.ws
+
+// backplane : https://www.backplane.io
+// Submitted by Anthony Voutas <anthony@backplane.io>
+backplaneapp.io
+
+// BetaInABox
+// Submitted by Adrian <adrian@betainabox.com>
+betainabox.com
+
+// BinaryLane : http://www.binarylane.com
+// Submitted by Nathan O'Sullivan <nathan@mammoth.com.au>
+bnr.la
+
+// Blackbaud, Inc. : https://www.blackbaud.com
+// Submitted by Paul Crowder <paul.crowder@blackbaud.com>
+blackbaudcdn.net
+
+// Boomla : https://boomla.com
+// Submitted by Tibor Halter <thalter@boomla.com>
+boomla.net
+
+// Boxfuse : https://boxfuse.com
+// Submitted by Axel Fontaine <axel@boxfuse.com>
+boxfuse.io
+
+// bplaced : https://www.bplaced.net/
+// Submitted by Miroslav Bozic <security@bplaced.net>
+square7.ch
+bplaced.com
+bplaced.de
+square7.de
+bplaced.net
+square7.net
+
+// BrowserSafetyMark
+// Submitted by Dave Tharp <browsersafetymark.io@quicinc.com>
+browsersafetymark.io
+
+// Bytemark Hosting : https://www.bytemark.co.uk
+// Submitted by Paul Cammish <paul.cammish@bytemark.co.uk>
+dh.bytemark.co.uk
+vm.bytemark.co.uk
+
+// callidomus : https://www.callidomus.com/
+// Submitted by Marcus Popp <admin@callidomus.com>
+mycd.eu
+
+// CentralNic : http://www.centralnic.com/names/domains
+// Submitted by registry <gavin.brown@centralnic.com>
+ae.org
+ar.com
+br.com
+cn.com
+com.de
+com.se
+de.com
+eu.com
+gb.com
+gb.net
+hu.com
+hu.net
+jp.net
+jpn.com
+kr.com
+mex.com
+no.com
+qc.com
+ru.com
+sa.com
+se.net
+uk.com
+uk.net
+us.com
+uy.com
+za.bz
+za.com
+
+// Africa.com Web Solutions Ltd : https://registry.africa.com
+// Submitted by Gavin Brown <gavin.brown@centralnic.com>
+africa.com
+
+// iDOT Services Limited : http://www.domain.gr.com
+// Submitted by Gavin Brown <gavin.brown@centralnic.com>
+gr.com
+
+// Radix FZC : http://domains.in.net
+// Submitted by Gavin Brown <gavin.brown@centralnic.com>
+in.net
+
+// US REGISTRY LLC : http://us.org
+// Submitted by Gavin Brown <gavin.brown@centralnic.com>
+us.org
+
+// co.com Registry, LLC : https://registry.co.com
+// Submitted by Gavin Brown <gavin.brown@centralnic.com>
+co.com
+
+// c.la : http://www.c.la/
+c.la
+
+// certmgr.org : https://certmgr.org
+// Submitted by B. Blechschmidt <hostmaster@certmgr.org>
+certmgr.org
+
+// Citrix : https://citrix.com
+// Submitted by Alex Stoddard <alex.stoddard@citrix.com>
+xenapponazure.com
+
+// ClearVox : http://www.clearvox.nl/
+// Submitted by Leon Rowland <leon@clearvox.nl>
+virtueeldomein.nl
+
+// Clever Cloud : https://www.clever-cloud.com/
+// Submitted by Quentin Adam <noc@clever-cloud.com>
+cleverapps.io
+
+// Cloud66 : https://www.cloud66.com/
+// Submitted by Khash Sajadi <khash@cloud66.com>
+c66.me
+cloud66.ws
+
+// CloudAccess.net : https://www.cloudaccess.net/
+// Submitted by Pawel Panek <noc@cloudaccess.net>
+jdevcloud.com
+wpdevcloud.com
+cloudaccess.host
+freesite.host
+cloudaccess.net
+
+// cloudControl : https://www.cloudcontrol.com/
+// Submitted by Tobias Wilken <tw@cloudcontrol.com>
+cloudcontrolled.com
+cloudcontrolapp.com
+
+// co.ca : http://registry.co.ca/
+co.ca
+
+// Co & Co : https://co-co.nl/
+// Submitted by Govert Versluis <govert@co-co.nl>
+*.otap.co
+
+// i-registry s.r.o. : http://www.i-registry.cz/
+// Submitted by Martin Semrad <semrad@i-registry.cz>
+co.cz
+
+// CDN77.com : http://www.cdn77.com
+// Submitted by Jan Krpes <jan.krpes@cdn77.com>
+c.cdn77.org
+cdn77-ssl.net
+r.cdn77.net
+rsc.cdn77.org
+ssl.origin.cdn77-secure.org
+
+// Cloud DNS Ltd : http://www.cloudns.net
+// Submitted by Aleksander Hristov <noc@cloudns.net>
+cloudns.asia
+cloudns.biz
+cloudns.club
+cloudns.cc
+cloudns.eu
+cloudns.in
+cloudns.info
+cloudns.org
+cloudns.pro
+cloudns.pw
+cloudns.us
+
+// Cloudeity Inc : https://cloudeity.com
+// Submitted by Stefan Dimitrov <contact@cloudeity.com>
+cloudeity.net
+
+// CNPY : https://cnpy.gdn
+// Submitted by Angelo Gladding <angelo@lahacker.net>
+cnpy.gdn
+
+// CoDNS B.V.
+co.nl
+co.no
+
+// Combell.com : https://www.combell.com
+// Submitted by Thomas Wouters <thomas.wouters@combellgroup.com>
+webhosting.be
+hosting-cluster.nl
+
+// COSIMO GmbH : http://www.cosimo.de
+// Submitted by Rene Marticke <rmarticke@cosimo.de>
+dyn.cosidns.de
+dynamisches-dns.de
+dnsupdater.de
+internet-dns.de
+l-o-g-i-n.de
+dynamic-dns.info
+feste-ip.net
+knx-server.net
+static-access.net
+
+// Craynic, s.r.o. : http://www.craynic.com/
+// Submitted by Ales Krajnik <ales.krajnik@craynic.com>
+realm.cz
+
+// Cryptonomic : https://cryptonomic.net/
+// Submitted by Andrew Cady <public-suffix-list@cryptonomic.net>
+*.cryptonomic.net
+
+// Cupcake : https://cupcake.io/
+// Submitted by Jonathan Rudenberg <jonathan@cupcake.io>
+cupcake.is
+
+// cyon GmbH : https://www.cyon.ch/
+// Submitted by Dominic Luechinger <dol@cyon.ch>
+cyon.link
+cyon.site
+
+// Daplie, Inc : https://daplie.com
+// Submitted by AJ ONeal <aj@daplie.com>
+daplie.me
+localhost.daplie.me
+
+// Datto, Inc. : https://www.datto.com/
+// Submitted by Philipp Heckel <ph@datto.com>
+dattolocal.com
+dattorelay.com
+dattoweb.com
+mydatto.com
+dattolocal.net
+mydatto.net
+
+// Dansk.net : http://www.dansk.net/
+// Submitted by Anani Voule <digital@digital.co.dk>
+biz.dk
+co.dk
+firm.dk
+reg.dk
+store.dk
+
+// dapps.earth : https://dapps.earth/
+// Submitted by Daniil Burdakov <icqkill@gmail.com>
+*.dapps.earth
+*.bzz.dapps.earth
+
+// Debian : https://www.debian.org/
+// Submitted by Peter Palfrader / Debian Sysadmin Team <dsa-publicsuffixlist@debian.org>
+debian.net
+
+// deSEC : https://desec.io/
+// Submitted by Peter Thomassen <peter@desec.io>
+dedyn.io
+
+// DNShome : https://www.dnshome.de/
+// Submitted by Norbert Auler <mail@dnshome.de>
+dnshome.de
+
+// DotArai : https://www.dotarai.com/
+// Submitted by Atsadawat Netcharadsang <atsadawat@dotarai.co.th>
+online.th
+shop.th
+
+// DrayTek Corp. : https://www.draytek.com/
+// Submitted by Paul Fang <mis@draytek.com>
+drayddns.com
+
+// DreamHost : http://www.dreamhost.com/
+// Submitted by Andrew Farmer <andrew.farmer@dreamhost.com>
+dreamhosters.com
+
+// Drobo : http://www.drobo.com/
+// Submitted by Ricardo Padilha <rpadilha@drobo.com>
+mydrobo.com
+
+// Drud Holdings, LLC. : https://www.drud.com/
+// Submitted by Kevin Bridges <kevin@drud.com>
+drud.io
+drud.us
+
+// DuckDNS : http://www.duckdns.org/
+// Submitted by Richard Harper <richard@duckdns.org>
+duckdns.org
+
+// dy.fi : http://dy.fi/
+// Submitted by Heikki Hannikainen <hessu@hes.iki.fi>
+dy.fi
+tunk.org
+
+// DynDNS.com : http://www.dyndns.com/services/dns/dyndns/
+dyndns-at-home.com
+dyndns-at-work.com
+dyndns-blog.com
+dyndns-free.com
+dyndns-home.com
+dyndns-ip.com
+dyndns-mail.com
+dyndns-office.com
+dyndns-pics.com
+dyndns-remote.com
+dyndns-server.com
+dyndns-web.com
+dyndns-wiki.com
+dyndns-work.com
+dyndns.biz
+dyndns.info
+dyndns.org
+dyndns.tv
+at-band-camp.net
+ath.cx
+barrel-of-knowledge.info
+barrell-of-knowledge.info
+better-than.tv
+blogdns.com
+blogdns.net
+blogdns.org
+blogsite.org
+boldlygoingnowhere.org
+broke-it.net
+buyshouses.net
+cechire.com
+dnsalias.com
+dnsalias.net
+dnsalias.org
+dnsdojo.com
+dnsdojo.net
+dnsdojo.org
+does-it.net
+doesntexist.com
+doesntexist.org
+dontexist.com
+dontexist.net
+dontexist.org
+doomdns.com
+doomdns.org
+dvrdns.org
+dyn-o-saur.com
+dynalias.com
+dynalias.net
+dynalias.org
+dynathome.net
+dyndns.ws
+endofinternet.net
+endofinternet.org
+endoftheinternet.org
+est-a-la-maison.com
+est-a-la-masion.com
+est-le-patron.com
+est-mon-blogueur.com
+for-better.biz
+for-more.biz
+for-our.info
+for-some.biz
+for-the.biz
+forgot.her.name
+forgot.his.name
+from-ak.com
+from-al.com
+from-ar.com
+from-az.net
+from-ca.com
+from-co.net
+from-ct.com
+from-dc.com
+from-de.com
+from-fl.com
+from-ga.com
+from-hi.com
+from-ia.com
+from-id.com
+from-il.com
+from-in.com
+from-ks.com
+from-ky.com
+from-la.net
+from-ma.com
+from-md.com
+from-me.org
+from-mi.com
+from-mn.com
+from-mo.com
+from-ms.com
+from-mt.com
+from-nc.com
+from-nd.com
+from-ne.com
+from-nh.com
+from-nj.com
+from-nm.com
+from-nv.com
+from-ny.net
+from-oh.com
+from-ok.com
+from-or.com
+from-pa.com
+from-pr.com
+from-ri.com
+from-sc.com
+from-sd.com
+from-tn.com
+from-tx.com
+from-ut.com
+from-va.com
+from-vt.com
+from-wa.com
+from-wi.com
+from-wv.com
+from-wy.com
+ftpaccess.cc
+fuettertdasnetz.de
+game-host.org
+game-server.cc
+getmyip.com
+gets-it.net
+go.dyndns.org
+gotdns.com
+gotdns.org
+groks-the.info
+groks-this.info
+ham-radio-op.net
+here-for-more.info
+hobby-site.com
+hobby-site.org
+home.dyndns.org
+homedns.org
+homeftp.net
+homeftp.org
+homeip.net
+homelinux.com
+homelinux.net
+homelinux.org
+homeunix.com
+homeunix.net
+homeunix.org
+iamallama.com
+in-the-band.net
+is-a-anarchist.com
+is-a-blogger.com
+is-a-bookkeeper.com
+is-a-bruinsfan.org
+is-a-bulls-fan.com
+is-a-candidate.org
+is-a-caterer.com
+is-a-celticsfan.org
+is-a-chef.com
+is-a-chef.net
+is-a-chef.org
+is-a-conservative.com
+is-a-cpa.com
+is-a-cubicle-slave.com
+is-a-democrat.com
+is-a-designer.com
+is-a-doctor.com
+is-a-financialadvisor.com
+is-a-geek.com
+is-a-geek.net
+is-a-geek.org
+is-a-green.com
+is-a-guru.com
+is-a-hard-worker.com
+is-a-hunter.com
+is-a-knight.org
+is-a-landscaper.com
+is-a-lawyer.com
+is-a-liberal.com
+is-a-libertarian.com
+is-a-linux-user.org
+is-a-llama.com
+is-a-musician.com
+is-a-nascarfan.com
+is-a-nurse.com
+is-a-painter.com
+is-a-patsfan.org
+is-a-personaltrainer.com
+is-a-photographer.com
+is-a-player.com
+is-a-republican.com
+is-a-rockstar.com
+is-a-socialist.com
+is-a-soxfan.org
+is-a-student.com
+is-a-teacher.com
+is-a-techie.com
+is-a-therapist.com
+is-an-accountant.com
+is-an-actor.com
+is-an-actress.com
+is-an-anarchist.com
+is-an-artist.com
+is-an-engineer.com
+is-an-entertainer.com
+is-by.us
+is-certified.com
+is-found.org
+is-gone.com
+is-into-anime.com
+is-into-cars.com
+is-into-cartoons.com
+is-into-games.com
+is-leet.com
+is-lost.org
+is-not-certified.com
+is-saved.org
+is-slick.com
+is-uberleet.com
+is-very-bad.org
+is-very-evil.org
+is-very-good.org
+is-very-nice.org
+is-very-sweet.org
+is-with-theband.com
+isa-geek.com
+isa-geek.net
+isa-geek.org
+isa-hockeynut.com
+issmarterthanyou.com
+isteingeek.de
+istmein.de
+kicks-ass.net
+kicks-ass.org
+knowsitall.info
+land-4-sale.us
+lebtimnetz.de
+leitungsen.de
+likes-pie.com
+likescandy.com
+merseine.nu
+mine.nu
+misconfused.org
+mypets.ws
+myphotos.cc
+neat-url.com
+office-on-the.net
+on-the-web.tv
+podzone.net
+podzone.org
+readmyblog.org
+saves-the-whales.com
+scrapper-site.net
+scrapping.cc
+selfip.biz
+selfip.com
+selfip.info
+selfip.net
+selfip.org
+sells-for-less.com
+sells-for-u.com
+sells-it.net
+sellsyourhome.org
+servebbs.com
+servebbs.net
+servebbs.org
+serveftp.net
+serveftp.org
+servegame.org
+shacknet.nu
+simple-url.com
+space-to-rent.com
+stuff-4-sale.org
+stuff-4-sale.us
+teaches-yoga.com
+thruhere.net
+traeumtgerade.de
+webhop.biz
+webhop.info
+webhop.net
+webhop.org
+worse-than.tv
+writesthisblog.com
+
+// ddnss.de : https://www.ddnss.de/
+// Submitted by Robert Niedziela <webmaster@ddnss.de>
+ddnss.de
+dyn.ddnss.de
+dyndns.ddnss.de
+dyndns1.de
+dyn-ip24.de
+home-webserver.de
+dyn.home-webserver.de
+myhome-server.de
+ddnss.org
+
+// Definima : http://www.definima.com/
+// Submitted by Maxence Bitterli <maxence@definima.com>
+definima.net
+definima.io
+
+// dnstrace.pro : https://dnstrace.pro/
+// Submitted by Chris Partridge <chris@partridge.tech>
+bci.dnstrace.pro
+
+// Dynu.com : https://www.dynu.com/
+// Submitted by Sue Ye <sue@dynu.com>
+ddnsfree.com
+ddnsgeek.com
+giize.com
+gleeze.com
+kozow.com
+loseyourip.com
+ooguy.com
+theworkpc.com
+casacam.net
+dynu.net
+accesscam.org
+camdvr.org
+freeddns.org
+mywire.org
+webredirect.org
+myddns.rocks
+blogsite.xyz
+
+// dynv6 : https://dynv6.com
+// Submitted by Dominik Menke <dom@digineo.de>
+dynv6.net
+
+// E4YOU spol. s.r.o. : https://e4you.cz/
+// Submitted by Vladimir Dudr <info@e4you.cz>
+e4.cz
+
+// Enalean SAS: https://www.enalean.com
+// Submitted by Thomas Cottier <thomas.cottier@enalean.com>
+mytuleap.com
+
+// Enonic : http://enonic.com/
+// Submitted by Erik Kaareng-Sunde <esu@enonic.com>
+enonic.io
+customer.enonic.io
+
+// EU.org https://eu.org/
+// Submitted by Pierre Beyssac <hostmaster@eu.org>
+eu.org
+al.eu.org
+asso.eu.org
+at.eu.org
+au.eu.org
+be.eu.org
+bg.eu.org
+ca.eu.org
+cd.eu.org
+ch.eu.org
+cn.eu.org
+cy.eu.org
+cz.eu.org
+de.eu.org
+dk.eu.org
+edu.eu.org
+ee.eu.org
+es.eu.org
+fi.eu.org
+fr.eu.org
+gr.eu.org
+hr.eu.org
+hu.eu.org
+ie.eu.org
+il.eu.org
+in.eu.org
+int.eu.org
+is.eu.org
+it.eu.org
+jp.eu.org
+kr.eu.org
+lt.eu.org
+lu.eu.org
+lv.eu.org
+mc.eu.org
+me.eu.org
+mk.eu.org
+mt.eu.org
+my.eu.org
+net.eu.org
+ng.eu.org
+nl.eu.org
+no.eu.org
+nz.eu.org
+paris.eu.org
+pl.eu.org
+pt.eu.org
+q-a.eu.org
+ro.eu.org
+ru.eu.org
+se.eu.org
+si.eu.org
+sk.eu.org
+tr.eu.org
+uk.eu.org
+us.eu.org
+
+// Evennode : http://www.evennode.com/
+// Submitted by Michal Kralik <support@evennode.com>
+eu-1.evennode.com
+eu-2.evennode.com
+eu-3.evennode.com
+eu-4.evennode.com
+us-1.evennode.com
+us-2.evennode.com
+us-3.evennode.com
+us-4.evennode.com
+
+// eDirect Corp. : https://hosting.url.com.tw/
+// Submitted by C.S. chang <cschang@corp.url.com.tw>
+twmail.cc
+twmail.net
+twmail.org
+mymailer.com.tw
+url.tw
+
+// Facebook, Inc.
+// Submitted by Peter Ruibal <public-suffix@fb.com>
+apps.fbsbx.com
+
+// FAITID : https://faitid.org/
+// Submitted by Maxim Alzoba <tech.contact@faitid.org>
+// https://www.flexireg.net/stat_info
+ru.net
+adygeya.ru
+bashkiria.ru
+bir.ru
+cbg.ru
+com.ru
+dagestan.ru
+grozny.ru
+kalmykia.ru
+kustanai.ru
+marine.ru
+mordovia.ru
+msk.ru
+mytis.ru
+nalchik.ru
+nov.ru
+pyatigorsk.ru
+spb.ru
+vladikavkaz.ru
+vladimir.ru
+abkhazia.su
+adygeya.su
+aktyubinsk.su
+arkhangelsk.su
+armenia.su
+ashgabad.su
+azerbaijan.su
+balashov.su
+bashkiria.su
+bryansk.su
+bukhara.su
+chimkent.su
+dagestan.su
+east-kazakhstan.su
+exnet.su
+georgia.su
+grozny.su
+ivanovo.su
+jambyl.su
+kalmykia.su
+kaluga.su
+karacol.su
+karaganda.su
+karelia.su
+khakassia.su
+krasnodar.su
+kurgan.su
+kustanai.su
+lenug.su
+mangyshlak.su
+mordovia.su
+msk.su
+murmansk.su
+nalchik.su
+navoi.su
+north-kazakhstan.su
+nov.su
+obninsk.su
+penza.su
+pokrovsk.su
+sochi.su
+spb.su
+tashkent.su
+termez.su
+togliatti.su
+troitsk.su
+tselinograd.su
+tula.su
+tuva.su
+vladikavkaz.su
+vladimir.su
+vologda.su
+
+// Fancy Bits, LLC : http://getchannels.com
+// Submitted by Aman Gupta <aman@getchannels.com>
+channelsdvr.net
+
+// Fastly Inc. : http://www.fastly.com/
+// Submitted by Fastly Security <security@fastly.com>
+fastly-terrarium.com
+fastlylb.net
+map.fastlylb.net
+freetls.fastly.net
+map.fastly.net
+a.prod.fastly.net
+global.prod.fastly.net
+a.ssl.fastly.net
+b.ssl.fastly.net
+global.ssl.fastly.net
+
+// FASTVPS EESTI OU : https://fastvps.ru/
+// Submitted by Likhachev Vasiliy <lihachev@fastvps.ru>
+fastpanel.direct
+fastvps-server.com
+
+// Featherhead : https://featherhead.xyz/
+// Submitted by Simon Menke <simon@featherhead.xyz>
+fhapp.xyz
+
+// Fedora : https://fedoraproject.org/
+// submitted by Patrick Uiterwijk <puiterwijk@fedoraproject.org>
+fedorainfracloud.org
+fedorapeople.org
+cloud.fedoraproject.org
+app.os.fedoraproject.org
+app.os.stg.fedoraproject.org
+
+// Fermax : https://fermax.com/
+// submitted by Koen Van Isterdael <k.vanisterdael@fermax.be>
+mydobiss.com
+
+// Filegear Inc. : https://www.filegear.com
+// Submitted by Jason Zhu <jason@owtware.com>
+filegear.me
+filegear-au.me
+filegear-de.me
+filegear-gb.me
+filegear-ie.me
+filegear-jp.me
+filegear-sg.me
+
+// Firebase, Inc.
+// Submitted by Chris Raynor <chris@firebase.com>
+firebaseapp.com
+
+// Flynn : https://flynn.io
+// Submitted by Jonathan Rudenberg <jonathan@flynn.io>
+flynnhub.com
+flynnhosting.net
+
+// Freebox : http://www.freebox.fr
+// Submitted by Romain Fliedel <rfliedel@freebox.fr>
+freebox-os.com
+freeboxos.com
+fbx-os.fr
+fbxos.fr
+freebox-os.fr
+freeboxos.fr
+
+// freedesktop.org : https://www.freedesktop.org
+// Submitted by Daniel Stone <daniel@fooishbar.org>
+freedesktop.org
+
+// Futureweb OG : http://www.futureweb.at
+// Submitted by Andreas Schnederle-Wagner <schnederle@futureweb.at>
+*.futurecms.at
+*.ex.futurecms.at
+*.in.futurecms.at
+futurehosting.at
+futuremailing.at
+*.ex.ortsinfo.at
+*.kunden.ortsinfo.at
+*.statics.cloud
+
+// GDS : https://www.gov.uk/service-manual/operations/operating-servicegovuk-subdomains
+// Submitted by David Illsley <david.illsley@digital.cabinet-office.gov.uk>
+service.gov.uk
+
+// GitHub, Inc.
+// Submitted by Patrick Toomey <security@github.com>
+github.io
+githubusercontent.com
+
+// GitLab, Inc.
+// Submitted by Alex Hanselka <alex@gitlab.com>
+gitlab.io
+
+// UKHomeOffice : https://www.gov.uk/government/organisations/home-office
+// Submitted by Jon Shanks <jon.shanks@digital.homeoffice.gov.uk>
+homeoffice.gov.uk
+
+// GlobeHosting, Inc.
+// Submitted by Zoltan Egresi <egresi@globehosting.com>
+ro.im
+shop.ro
+
+// GoIP DNS Services : http://www.goip.de
+// Submitted by Christian Poulter <milchstrasse@goip.de>
+goip.de
+
+// Google, Inc.
+// Submitted by Eduardo Vela <evn@google.com>
+run.app
+a.run.app
+*.0emm.com
+appspot.com
+blogspot.ae
+blogspot.al
+blogspot.am
+blogspot.ba
+blogspot.be
+blogspot.bg
+blogspot.bj
+blogspot.ca
+blogspot.cf
+blogspot.ch
+blogspot.cl
+blogspot.co.at
+blogspot.co.id
+blogspot.co.il
+blogspot.co.ke
+blogspot.co.nz
+blogspot.co.uk
+blogspot.co.za
+blogspot.com
+blogspot.com.ar
+blogspot.com.au
+blogspot.com.br
+blogspot.com.by
+blogspot.com.co
+blogspot.com.cy
+blogspot.com.ee
+blogspot.com.eg
+blogspot.com.es
+blogspot.com.mt
+blogspot.com.ng
+blogspot.com.tr
+blogspot.com.uy
+blogspot.cv
+blogspot.cz
+blogspot.de
+blogspot.dk
+blogspot.fi
+blogspot.fr
+blogspot.gr
+blogspot.hk
+blogspot.hr
+blogspot.hu
+blogspot.ie
+blogspot.in
+blogspot.is
+blogspot.it
+blogspot.jp
+blogspot.kr
+blogspot.li
+blogspot.lt
+blogspot.lu
+blogspot.md
+blogspot.mk
+blogspot.mr
+blogspot.mx
+blogspot.my
+blogspot.nl
+blogspot.no
+blogspot.pe
+blogspot.pt
+blogspot.qa
+blogspot.re
+blogspot.ro
+blogspot.rs
+blogspot.ru
+blogspot.se
+blogspot.sg
+blogspot.si
+blogspot.sk
+blogspot.sn
+blogspot.td
+blogspot.tw
+blogspot.ug
+blogspot.vn
+cloudfunctions.net
+cloud.goog
+codespot.com
+googleapis.com
+googlecode.com
+pagespeedmobilizer.com
+publishproxy.com
+withgoogle.com
+withyoutube.com
+
+// Hashbang : https://hashbang.sh
+hashbang.sh
+
+// Hasura : https://hasura.io
+// Submitted by Shahidh K Muhammed <shahidh@hasura.io>
+hasura.app
+hasura-app.io
+
+// Hepforge : https://www.hepforge.org
+// Submitted by David Grellscheid <admin@hepforge.org>
+hepforge.org
+
+// Heroku : https://www.heroku.com/
+// Submitted by Tom Maher <tmaher@heroku.com>
+herokuapp.com
+herokussl.com
+
+// Hibernating Rhinos
+// Submitted by Oren Eini <oren@ravendb.net>
+myravendb.com
+ravendb.community
+ravendb.me
+development.run
+ravendb.run
+
+// Ici la Lune : http://www.icilalune.com/
+// Submitted by Simon Morvan <simon@icilalune.com>
+moonscale.net
+
+// iki.fi
+// Submitted by Hannu Aronsson <haa@iki.fi>
+iki.fi
+
+// Individual Network Berlin e.V. : https://www.in-berlin.de/
+// Submitted by Christian Seitz <chris@in-berlin.de>
+dyn-berlin.de
+in-berlin.de
+in-brb.de
+in-butter.de
+in-dsl.de
+in-dsl.net
+in-dsl.org
+in-vpn.de
+in-vpn.net
+in-vpn.org
+
+// info.at : http://www.info.at/
+biz.at
+info.at
+
+// info.cx : http://info.cx
+// Submitted by Jacob Slater <whois@igloo.to>
+info.cx
+
+// Interlegis : http://www.interlegis.leg.br
+// Submitted by Gabriel Ferreira <registrobr@interlegis.leg.br>
+ac.leg.br
+al.leg.br
+am.leg.br
+ap.leg.br
+ba.leg.br
+ce.leg.br
+df.leg.br
+es.leg.br
+go.leg.br
+ma.leg.br
+mg.leg.br
+ms.leg.br
+mt.leg.br
+pa.leg.br
+pb.leg.br
+pe.leg.br
+pi.leg.br
+pr.leg.br
+rj.leg.br
+rn.leg.br
+ro.leg.br
+rr.leg.br
+rs.leg.br
+sc.leg.br
+se.leg.br
+sp.leg.br
+to.leg.br
+
+// intermetrics GmbH : https://pixolino.com/
+// Submitted by Wolfgang Schwarz <admin@intermetrics.de>
+pixolino.com
+
+// IPiFony Systems, Inc. : https://www.ipifony.com/
+// Submitted by Matthew Hardeman <mhardeman@ipifony.com>
+ipifony.net
+
+// IServ GmbH : https://iserv.eu
+// Submitted by Kim-Alexander Brodowski <kim.brodowski@iserv.eu>
+mein-iserv.de
+test-iserv.de
+
+// Jino : https://www.jino.ru
+// Submitted by Sergey Ulyashin <ulyashin@jino.ru>
+myjino.ru
+*.hosting.myjino.ru
+*.landing.myjino.ru
+*.spectrum.myjino.ru
+*.vps.myjino.ru
+
+// Joyent : https://www.joyent.com/
+// Submitted by Brian Bennett <brian.bennett@joyent.com>
+*.triton.zone
+*.cns.joyent.com
+
+// JS.ORG : http://dns.js.org
+// Submitted by Stefan Keim <admin@js.org>
+js.org
+
+// Keyweb AG : https://www.keyweb.de
+// Submitted by Martin Dannehl <postmaster@keymachine.de>
+keymachine.de
+
+// KnightPoint Systems, LLC : http://www.knightpoint.com/
+// Submitted by Roy Keene <rkeene@knightpoint.com>
+knightpoint.systems
+
+// .KRD : http://nic.krd/data/krd/Registration%20Policy.pdf
+co.krd
+edu.krd
+
+// LCube - Professional hosting e.K. : https://www.lcube-webhosting.de
+// Submitted by Lars Laehn <info@lcube.de>
+git-repos.de
+lcube-server.de
+svn-repos.de
+
+// Leadpages : https://www.leadpages.net
+// Submitted by Greg Dallavalle <domains@leadpages.net>
+leadpages.co
+lpages.co
+lpusercontent.com
+
+// Lifetime Hosting : https://Lifetime.Hosting/
+// Submitted by Mike Fillator <support@lifetime.hosting>
+co.business
+co.education
+co.events
+co.financial
+co.network
+co.place
+co.technology
+
+// Lightmaker Property Manager, Inc. : https://app.lmpm.com/
+// Submitted by Greg Holland <greg.holland@lmpm.com>
+app.lmpm.com
+
+// Linki Tools UG : https://linki.tools
+// Submitted by Paulo Matos <pmatos@linki.tools>
+linkitools.space
+
+// linkyard ldt: https://www.linkyard.ch/
+// Submitted by Mario Siegenthaler <mario.siegenthaler@linkyard.ch>
+linkyard.cloud
+linkyard-cloud.ch
+
+// LiquidNet Ltd : http://www.liquidnetlimited.com/
+// Submitted by Victor Velchev <admin@liquidnetlimited.com>
+we.bs
+
+// LubMAN UMCS Sp. z o.o : https://lubman.pl/
+// Submitted by Ireneusz Maliszewski <ireneusz.maliszewski@lubman.pl>
+krasnik.pl
+leczna.pl
+lubartow.pl
+lublin.pl
+poniatowa.pl
+swidnik.pl
+
+// Lug.org.uk : https://lug.org.uk
+// Submitted by Jon Spriggs <admin@lug.org.uk>
+uklugs.org
+glug.org.uk
+lug.org.uk
+lugs.org.uk
+
+// Lukanet Ltd : https://lukanet.com
+// Submitted by Anton Avramov <register@lukanet.com>
+barsy.bg
+barsy.co.uk
+barsyonline.co.uk
+barsycenter.com
+barsyonline.com
+barsy.club
+barsy.de
+barsy.eu
+barsy.in
+barsy.info
+barsy.io
+barsy.me
+barsy.menu
+barsy.mobi
+barsy.net
+barsy.online
+barsy.org
+barsy.pro
+barsy.pub
+barsy.shop
+barsy.site
+barsy.support
+barsy.uk
+
+// Magento Commerce
+// Submitted by Damien Tournoud <dtournoud@magento.cloud>
+*.magentosite.cloud
+
+// May First - People Link : https://mayfirst.org/
+// Submitted by Jamie McClelland <info@mayfirst.org>
+mayfirst.info
+mayfirst.org
+
+// Mail.Ru Group : https://hb.cldmail.ru
+// Submitted by Ilya Zaretskiy <zaretskiy@corp.mail.ru>
+hb.cldmail.ru
+
+// Memset hosting : https://www.memset.com
+// Submitted by Tom Whitwell <domains@memset.com>
+miniserver.com
+memset.net
+
+// MetaCentrum, CESNET z.s.p.o. : https://www.metacentrum.cz/en/
+// Submitted by Zdeněk Šustr <zdenek.sustr@cesnet.cz>
+cloud.metacentrum.cz
+custom.metacentrum.cz
+
+// MetaCentrum, CESNET z.s.p.o. : https://www.metacentrum.cz/en/
+// Submitted by Radim Janča <janca@cesnet.cz>
+flt.cloud.muni.cz
+usr.cloud.muni.cz
+
+// Meteor Development Group : https://www.meteor.com/hosting
+// Submitted by Pierre Carrier <pierre@meteor.com>
+meteorapp.com
+eu.meteorapp.com
+
+// Michau Enterprises Limited : http://www.co.pl/
+co.pl
+
+// Microsoft Corporation : http://microsoft.com
+// Submitted by Justin Luk <juluk@microsoft.com>
+azurecontainer.io
+azurewebsites.net
+azure-mobile.net
+cloudapp.net
+
+// Mozilla Corporation : https://mozilla.com
+// Submitted by Ben Francis <bfrancis@mozilla.com>
+mozilla-iot.org
+
+// Mozilla Foundation : https://mozilla.org/
+// Submitted by glob <glob@mozilla.com>
+bmoattachments.org
+
+// MSK-IX : https://www.msk-ix.ru/
+// Submitted by Khannanov Roman <r.khannanov@msk-ix.ru>
+net.ru
+org.ru
+pp.ru
+
+// Netlify : https://www.netlify.com
+// Submitted by Jessica Parsons <jessica@netlify.com>
+bitballoon.com
+netlify.com
+
+// Neustar Inc.
+// Submitted by Trung Tran <Trung.Tran@neustar.biz>
+4u.com
+
+// ngrok : https://ngrok.com/
+// Submitted by Alan Shreve <alan@ngrok.com>
+ngrok.io
+
+// Nimbus Hosting Ltd. : https://www.nimbushosting.co.uk/
+// Submitted by Nicholas Ford <nick@nimbushosting.co.uk>
+nh-serv.co.uk
+
+// NFSN, Inc. : https://www.NearlyFreeSpeech.NET/
+// Submitted by Jeff Wheelhouse <support@nearlyfreespeech.net>
+nfshost.com
+
+// Now-DNS : https://now-dns.com
+// Submitted by Steve Russell <steve@now-dns.com>
+dnsking.ch
+mypi.co
+n4t.co
+001www.com
+ddnslive.com
+myiphost.com
+forumz.info
+16-b.it
+32-b.it
+64-b.it
+soundcast.me
+tcp4.me
+dnsup.net
+hicam.net
+now-dns.net
+ownip.net
+vpndns.net
+dynserv.org
+now-dns.org
+x443.pw
+now-dns.top
+ntdll.top
+freeddns.us
+crafting.xyz
+zapto.xyz
+
+// nsupdate.info : https://www.nsupdate.info/
+// Submitted by Thomas Waldmann <info@nsupdate.info>
+nsupdate.info
+nerdpol.ovh
+
+// No-IP.com : https://noip.com/
+// Submitted by Deven Reza <publicsuffixlist@noip.com>
+blogsyte.com
+brasilia.me
+cable-modem.org
+ciscofreak.com
+collegefan.org
+couchpotatofries.org
+damnserver.com
+ddns.me
+ditchyourip.com
+dnsfor.me
+dnsiskinky.com
+dvrcam.info
+dynns.com
+eating-organic.net
+fantasyleague.cc
+geekgalaxy.com
+golffan.us
+health-carereform.com
+homesecuritymac.com
+homesecuritypc.com
+hopto.me
+ilovecollege.info
+loginto.me
+mlbfan.org
+mmafan.biz
+myactivedirectory.com
+mydissent.net
+myeffect.net
+mymediapc.net
+mypsx.net
+mysecuritycamera.com
+mysecuritycamera.net
+mysecuritycamera.org
+net-freaks.com
+nflfan.org
+nhlfan.net
+no-ip.ca
+no-ip.co.uk
+no-ip.net
+noip.us
+onthewifi.com
+pgafan.net
+point2this.com
+pointto.us
+privatizehealthinsurance.net
+quicksytes.com
+read-books.org
+securitytactics.com
+serveexchange.com
+servehumour.com
+servep2p.com
+servesarcasm.com
+stufftoread.com
+ufcfan.org
+unusualperson.com
+workisboring.com
+3utilities.com
+bounceme.net
+ddns.net
+ddnsking.com
+gotdns.ch
+hopto.org
+myftp.biz
+myftp.org
+myvnc.com
+no-ip.biz
+no-ip.info
+no-ip.org
+noip.me
+redirectme.net
+servebeer.com
+serveblog.net
+servecounterstrike.com
+serveftp.com
+servegame.com
+servehalflife.com
+servehttp.com
+serveirc.com
+serveminecraft.net
+servemp3.com
+servepics.com
+servequake.com
+sytes.net
+webhop.me
+zapto.org
+
+// NodeArt : https://nodeart.io
+// Submitted by Konstantin Nosov <Nosov@nodeart.io>
+stage.nodeart.io
+
+// Nodum B.V. : https://nodum.io/
+// Submitted by Wietse Wind <hello+publicsuffixlist@nodum.io>
+nodum.co
+nodum.io
+
+// Nucleos Inc. : https://nucleos.com
+// Submitted by Piotr Zduniak <piotr@nucleos.com>
+pcloud.host
+
+// NYC.mn : http://www.information.nyc.mn
+// Submitted by Matthew Brown <mattbrown@nyc.mn>
+nyc.mn
+
+// NymNom : https://nymnom.com/
+// Submitted by Dave McCormack <dave.mccormack@nymnom.com>
+nom.ae
+nom.af
+nom.ai
+nom.al
+nym.by
+nym.bz
+nom.cl
+nom.gd
+nom.ge
+nom.gl
+nym.gr
+nom.gt
+nym.gy
+nom.hn
+nym.ie
+nom.im
+nom.ke
+nym.kz
+nym.la
+nym.lc
+nom.li
+nym.li
+nym.lt
+nym.lu
+nym.me
+nom.mk
+nym.mn
+nym.mx
+nom.nu
+nym.nz
+nym.pe
+nym.pt
+nom.pw
+nom.qa
+nym.ro
+nom.rs
+nom.si
+nym.sk
+nom.st
+nym.su
+nym.sx
+nom.tj
+nym.tw
+nom.ug
+nom.uy
+nom.vc
+nom.vg
+
+// Octopodal Solutions, LLC. : https://ulterius.io/
+// Submitted by Andrew Sampson <andrew@ulterius.io>
+cya.gg
+
+// Omnibond Systems, LLC. : https://www.omnibond.com
+// Submitted by Cole Estep <cole@omnibond.com>
+cloudycluster.net
+
+// One Fold Media : http://www.onefoldmedia.com/
+// Submitted by Eddie Jones <eddie@onefoldmedia.com>
+nid.io
+
+// OpenCraft GmbH : http://opencraft.com/
+// Submitted by Sven Marnach <sven@opencraft.com>
+opencraft.hosting
+
+// Opera Software, A.S.A.
+// Submitted by Yngve Pettersen <yngve@opera.com>
+operaunite.com
+
+// OutSystems
+// Submitted by Duarte Santos <domain-admin@outsystemscloud.com>
+outsystemscloud.com
+
+// OwnProvider GmbH: http://www.ownprovider.com
+// Submitted by Jan Moennich <jan.moennich@ownprovider.com>
+ownprovider.com
+own.pm
+
+// OX : http://www.ox.rs
+// Submitted by Adam Grand <webmaster@mail.ox.rs>
+ox.rs
+
+// oy.lc
+// Submitted by Charly Coste <changaco@changaco.oy.lc>
+oy.lc
+
+// Pagefog : https://pagefog.com/
+// Submitted by Derek Myers <derek@pagefog.com>
+pgfog.com
+
+// Pagefront : https://www.pagefronthq.com/
+// Submitted by Jason Kriss <jason@pagefronthq.com>
+pagefrontapp.com
+
+// .pl domains (grandfathered)
+art.pl
+gliwice.pl
+krakow.pl
+poznan.pl
+wroc.pl
+zakopane.pl
+
+// Pantheon Systems, Inc. : https://pantheon.io/
+// Submitted by Gary Dylina <gary@pantheon.io>
+pantheonsite.io
+gotpantheon.com
+
+// Peplink | Pepwave : http://peplink.com/
+// Submitted by Steve Leung <steveleung@peplink.com>
+mypep.link
+
+// Planet-Work : https://www.planet-work.com/
+// Submitted by Frédéric VANNIÈRE <f.vanniere@planet-work.com>
+on-web.fr
+
+// Platform.sh : https://platform.sh
+// Submitted by Nikola Kotur <nikola@platform.sh>
+*.platform.sh
+*.platformsh.site
+
+// prgmr.com : https://prgmr.com/
+// Submitted by Sarah Newman <owner@prgmr.com>
+xen.prgmr.com
+
+// priv.at : http://www.nic.priv.at/
+// Submitted by registry <lendl@nic.at>
+priv.at
+
+// Protonet GmbH : http://protonet.io
+// Submitted by Martin Meier <admin@protonet.io>
+protonet.io
+
+// Publication Presse Communication SARL : https://ppcom.fr
+// Submitted by Yaacov Akiba Slama <admin@chirurgiens-dentistes-en-france.fr>
+chirurgiens-dentistes-en-france.fr
+byen.site
+
+// Redstar Consultants : https://www.redstarconsultants.com/
+// Submitted by Jons Slemmer <jons@redstarconsultants.com>
+instantcloud.cn
+
+// Russian Academy of Sciences
+// Submitted by Tech Support <support@rasnet.ru>
+ras.ru
+
+// QA2
+// Submitted by Daniel Dent (https://www.danieldent.com/)
+qa2.com
+
+// QNAP System Inc : https://www.qnap.com
+// Submitted by Nick Chang <nickchang@qnap.com>
+dev-myqnapcloud.com
+alpha-myqnapcloud.com
+myqnapcloud.com
+
+// Quip : https://quip.com
+// Submitted by Patrick Linehan <plinehan@quip.com>
+*.quipelements.com
+
+// Qutheory LLC : http://qutheory.io
+// Submitted by Jonas Schwartz <jonas@qutheory.io>
+vapor.cloud
+vaporcloud.io
+
+// Rackmaze LLC : https://www.rackmaze.com
+// Submitted by Kirill Pertsev <kika@rackmaze.com>
+rackmaze.com
+rackmaze.net
+
+// Read The Docs, Inc : https://www.readthedocs.org
+// Submitted by David Fischer <team@readthedocs.org>
+readthedocs.io
+
+// Red Hat, Inc. OpenShift : https://openshift.redhat.com/
+// Submitted by Tim Kramer <tkramer@rhcloud.com>
+rhcloud.com
+
+// Resin.io : https://resin.io
+// Submitted by Tim Perry <tim@resin.io>
+resindevice.io
+devices.resinstaging.io
+
+// RethinkDB : https://www.rethinkdb.com/
+// Submitted by Chris Kastorff <info@rethinkdb.com>
+hzc.io
+
+// Revitalised Limited : http://www.revitalised.co.uk
+// Submitted by Jack Price <jack@revitalised.co.uk>
+wellbeingzone.eu
+ptplus.fit
+wellbeingzone.co.uk
+
+// Sandstorm Development Group, Inc. : https://sandcats.io/
+// Submitted by Asheesh Laroia <asheesh@sandstorm.io>
+sandcats.io
+
+// SBE network solutions GmbH : https://www.sbe.de/
+// Submitted by Norman Meilick <nm@sbe.de>
+logoip.de
+logoip.com
+
+// schokokeks.org GbR : https://schokokeks.org/
+// Submitted by Hanno Böck <hanno@schokokeks.org>
+schokokeks.net
+
+// Scry Security : http://www.scrysec.com
+// Submitted by Shante Adam <shante@skyhat.io>
+scrysec.com
+
+// Securepoint GmbH : https://www.securepoint.de
+// Submitted by Erik Anders <erik.anders@securepoint.de>
+firewall-gateway.com
+firewall-gateway.de
+my-gateway.de
+my-router.de
+spdns.de
+spdns.eu
+firewall-gateway.net
+my-firewall.org
+myfirewall.org
+spdns.org
+
+// SensioLabs, SAS : https://sensiolabs.com/
+// Submitted by Fabien Potencier <fabien.potencier@sensiolabs.com>
+*.s5y.io
+*.sensiosite.cloud
+
+// Service Online LLC : http://drs.ua/
+// Submitted by Serhii Bulakh <support@drs.ua>
+biz.ua
+co.ua
+pp.ua
+
+// ShiftEdit : https://shiftedit.net/
+// Submitted by Adam Jimenez <adam@shiftcreate.com>
+shiftedit.io
+
+// Shopblocks : http://www.shopblocks.com/
+// Submitted by Alex Bowers <alex@shopblocks.com>
+myshopblocks.com
+
+// SinaAppEngine : http://sae.sina.com.cn/
+// Submitted by SinaAppEngine <saesupport@sinacloud.com>
+1kapp.com
+appchizi.com
+applinzi.com
+sinaapp.com
+vipsinaapp.com
+
+// Siteleaf : https://www.siteleaf.com/
+// Submitted by Skylar Challand <support@siteleaf.com>
+siteleaf.net
+
+// Skyhat : http://www.skyhat.io
+// Submitted by Shante Adam <shante@skyhat.io>
+bounty-full.com
+alpha.bounty-full.com
+beta.bounty-full.com
+
+// staticland : https://static.land
+// Submitted by Seth Vincent <sethvincent@gmail.com>
+static.land
+dev.static.land
+sites.static.land
+
+// SourceLair PC : https://www.sourcelair.com
+// Submitted by Antonis Kalipetis <akalipetis@sourcelair.com>
+apps.lair.io
+*.stolos.io
+
+// SpaceKit : https://www.spacekit.io/
+// Submitted by Reza Akhavan <spacekit.io@gmail.com>
+spacekit.io
+
+// SpeedPartner GmbH: https://www.speedpartner.de/
+// Submitted by Stefan Neufeind <info@speedpartner.de>
+customer.speedpartner.de
+
+// Standard Library : https://stdlib.com
+// Submitted by Jacob Lee <jacob@stdlib.com>
+api.stdlib.com
+
+// Storj Labs Inc. : https://storj.io/
+// Submitted by Philip Hutchins <hostmaster@storj.io>
+storj.farm
+
+// Studenten Net Twente : http://www.snt.utwente.nl/
+// Submitted by Silke Hofstra <syscom@snt.utwente.nl>
+utwente.io
+
+// Sub 6 Limited: http://www.sub6.com
+// Submitted by Dan Miller <dm@sub6.com>
+temp-dns.com
+
+// Swisscom Application Cloud: https://developer.swisscom.com
+// Submitted by Matthias.Winzeler <matthias.winzeler@swisscom.com>
+applicationcloud.io
+scapp.io
+
+// Synology, Inc. : https://www.synology.com/
+// Submitted by Rony Weng <ronyweng@synology.com>
+diskstation.me
+dscloud.biz
+dscloud.me
+dscloud.mobi
+dsmynas.com
+dsmynas.net
+dsmynas.org
+familyds.com
+familyds.net
+familyds.org
+i234.me
+myds.me
+synology.me
+vpnplus.to
+
+// TAIFUN Software AG : http://taifun-software.de
+// Submitted by Bjoern Henke <dev-server@taifun-software.de>
+taifun-dns.de
+
+// TASK geographical domains (www.task.gda.pl/uslugi/dns)
+gda.pl
+gdansk.pl
+gdynia.pl
+med.pl
+sopot.pl
+
+// Telebit : https://telebit.cloud
+// Submitted by AJ ONeal <aj@telebit.cloud>
+telebit.app
+telebit.io
+*.telebit.xyz
+
+// The Gwiddle Foundation : https://gwiddlefoundation.org.uk
+// Submitted by Joshua Bayfield <joshua.bayfield@gwiddlefoundation.org.uk>
+gwiddle.co.uk
+
+// Thingdust AG : https://thingdust.com/
+// Submitted by Adrian Imboden <adi@thingdust.com>
+cust.dev.thingdust.io
+cust.disrec.thingdust.io
+cust.prod.thingdust.io
+cust.testing.thingdust.io
+
+// TownNews.com : http://www.townnews.com
+// Submitted by Dustin Ward <dward@townnews.com>
+bloxcms.com
+townnews-staging.com
+
+// TrafficPlex GmbH : https://www.trafficplex.de/
+// Submitted by Phillipp Röll <phillipp.roell@trafficplex.de>
+12hp.at
+2ix.at
+4lima.at
+lima-city.at
+12hp.ch
+2ix.ch
+4lima.ch
+lima-city.ch
+trafficplex.cloud
+de.cool
+12hp.de
+2ix.de
+4lima.de
+lima-city.de
+1337.pictures
+clan.rip
+lima-city.rocks
+webspace.rocks
+lima.zone
+
+// TransIP : https://www.transip.nl
+// Submitted by Rory Breuk <rbreuk@transip.nl>
+*.transurl.be
+*.transurl.eu
+*.transurl.nl
+
+// TuxFamily : http://tuxfamily.org
+// Submitted by TuxFamily administrators <adm@staff.tuxfamily.org>
+tuxfamily.org
+
+// TwoDNS : https://www.twodns.de/
+// Submitted by TwoDNS-Support <support@two-dns.de>
+dd-dns.de
+diskstation.eu
+diskstation.org
+dray-dns.de
+draydns.de
+dyn-vpn.de
+dynvpn.de
+mein-vigor.de
+my-vigor.de
+my-wan.de
+syno-ds.de
+synology-diskstation.de
+synology-ds.de
+
+// Uberspace : https://uberspace.de
+// Submitted by Moritz Werner <mwerner@jonaspasche.com>
+uber.space
+*.uberspace.de
+
+// UDR Limited : http://www.udr.hk.com
+// Submitted by registry <hostmaster@udr.hk.com>
+hk.com
+hk.org
+ltd.hk
+inc.hk
+
+// United Gameserver GmbH : https://united-gameserver.de
+// Submitted by Stefan Schwarz <sysadm@united-gameserver.de>
+virtualuser.de
+virtual-user.de
+
+// .US
+// Submitted by Ed Moore <Ed.Moore@lib.de.us>
+lib.de.us
+
+// VeryPositive SIA : http://very.lv
+// Submitted by Danko Aleksejevs <danko@very.lv>
+2038.io
+
+// Viprinet Europe GmbH : http://www.viprinet.com
+// Submitted by Simon Kissel <hostmaster@viprinet.com>
+router.management
+
+// Virtual-Info : https://www.virtual-info.info/
+// Submitted by Adnan RIHAN <hostmaster@v-info.info>
+v-info.info
+
+// WeDeploy by Liferay, Inc. : https://www.wedeploy.com
+// Submitted by Henrique Vicente <security@wedeploy.com>
+wedeploy.io
+wedeploy.me
+wedeploy.sh
+
+// Western Digital Technologies, Inc : https://www.wdc.com
+// Submitted by Jung Jin <jungseok.jin@wdc.com>
+remotewd.com
+
+// Wikimedia Labs : https://wikitech.wikimedia.org
+// Submitted by Yuvi Panda <yuvipanda@wikimedia.org>
+wmflabs.org
+
+// XenonCloud GbR: https://xenoncloud.net
+// Submitted by Julian Uphoff <publicsuffixlist@xenoncloud.net>
+half.host
+
+// XnBay Technology : http://www.xnbay.com/
+// Submitted by XnBay Developer <developer.xncloud@gmail.com>
+xnbay.com
+u2.xnbay.com
+u2-local.xnbay.com
+
+// XS4ALL Internet bv : https://www.xs4all.nl/
+// Submitted by Daniel Mostertman <unixbeheer+publicsuffix@xs4all.net>
+cistron.nl
+demon.nl
+xs4all.space
+
+// YesCourse Pty Ltd : https://yescourse.com
+// Submitted by Atul Bhouraskar <atul@yescourse.com>
+official.academy
+
+// Yola : https://www.yola.com/
+// Submitted by Stefano Rivera <stefano@yola.com>
+yolasite.com
+
+// Yombo : https://yombo.net
+// Submitted by Mitch Schwenk <mitch@yombo.net>
+ybo.faith
+yombo.me
+homelink.one
+ybo.party
+ybo.review
+ybo.science
+ybo.trade
+
+// Yunohost : https://yunohost.org
+// Submitted by Valentin Grimaud <security@yunohost.org>
+nohost.me
+noho.st
+
+// ZaNiC : http://www.za.net/
+// Submitted by registry <hostmaster@nic.za.net>
+za.net
+za.org
+
+// Zeit, Inc. : https://zeit.domains/
+// Submitted by Olli Vanhoja <olli@zeit.co>
+now.sh
+
+// Zine EOOD : https://zine.bg/
+// Submitted by Martin Angelov <martin@zine.bg>
+bss.design
+
+// Zone.id : https://zone.id/
+// Submitted by Su Hendro <admin@zone.id>
+zone.id
+
+// ===END PRIVATE DOMAINS===
diff --git a/test/data/public_suffix_list_short.txt b/test/data/public_suffix_list_short.txt
new file mode 100644
index 0000000..a9069ba
--- /dev/null
+++ b/test/data/public_suffix_list_short.txt
@@ -0,0 +1,52 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+// Please pull this list from, and only from https://publicsuffix.org/list/public_suffix_list.dat,
+// rather than any other VCS sites. Pulling from any other URL is not guaranteed to be supported.
+
+// Instructions on pulling and using this list can be found at https://publicsuffix.org/list/.
+
+// ===BEGIN ICANN DOMAINS===
+
+// ac : https://en.wikipedia.org/wiki/.ac
+ac
+com.ac
+edu.ac
+gov.ac
+net.ac
+mil.ac
+org.ac
+
+// aero : see https://www.information.aero/index.php?id=66
+aero
+accident-investigation.aero
+accident-prevention.aero
+aerobatic.aero
+aeroclub.aero
+aerodrome.aero
+agents.aero
+aircraft.aero
+airline.aero
+airport.aero
+air-surveillance.aero
+airtraffic.aero
+air-traffic-control.aero
+
+// ck : https://en.wikipedia.org/wiki/.ck
+*.ck
+!www.ck
+
+// cl : https://en.wikipedia.org/wiki/.cl
+cl
+gov.cl
+gob.cl
+co.cl
+mil.cl
+
+// cm : https://en.wikipedia.org/wiki/.cm plus bug 981927
+cm
+co.cm
+com.cm
+gov.cm
+net.cm
\ No newline at end of file
diff --git a/test/etld_blocking_test.cc b/test/etld_blocking_test.cc
new file mode 100644
index 0000000..6b99f45
--- /dev/null
+++ b/test/etld_blocking_test.cc
@@ -0,0 +1,258 @@
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <string>
+#include <iostream>
+#include <vector>
+#include <set>
+#include <fstream>
+#include "./CppUnitLite/TestHarness.h"
+#include "./CppUnitLite/Test.h"
+#include "./ad_block_client.h"
+#include "./filter.h"
+#include "./etld/types.h"
+#include "./etld/matcher.h"
+#include "./etld/parser.h"
+#include "./etld/domain.h"
+#include "./etld/public_suffix_rule.h"
+#include "./etld/public_suffix_rule_set.h"
+#include "./etld/serialization.h"
+
+using std::string;
+
+bool testThirdPartyBlockingWithRulesDomainAndPublixSuffixList(
+    const string &rules, const string &url, const string &domain,
+    const string &public_suffix_list, const string &expected_rule,
+    bool should_match) {
+  AdBlockClient client;
+  client.parse(rules.c_str(), true);
+  client.parsePublicSuffixRules(public_suffix_list.c_str());
+
+  Filter matching_filter;
+  Filter *matching_ptr = &matching_filter;
+  Filter exception_filter;
+  Filter *exception_ptr = &exception_filter;
+
+  bool is_match = client.findMatchingFilters(url.c_str(), FONoFilterOption,
+    domain.c_str(), &matching_ptr, &exception_ptr);
+
+  if (is_match != should_match) {
+    std::cout << "Expected " << (should_match ? "a match" : "no match")
+              << " but received " << (is_match ? "a match" : "no match")
+              << "." << std::endl;
+    return false;
+  }
+
+  if (!should_match) {
+    return true;
+  }
+
+  bool is_expected_rule = strcmp(
+    matching_ptr->ruleDefinition, expected_rule.c_str()) == 0;
+
+  if (is_expected_rule) {
+    return true;
+  }
+
+  std::cout << "Did not return the expected matching rule.  Expected '"
+            << expected_rule << "' but received '"
+            << matching_ptr->ruleDefinition << "'" << std::endl;
+  return false;
+}
+
+TEST(etldBlockingTests, basic) {
+  std::ifstream ifs("./test/data/public_suffix_list.dat");
+  const string public_suffix_rules((std::istreambuf_iterator<char>(ifs)),
+                                   (std::istreambuf_iterator<char>()));
+  const string third_party_rule = "||s3.amazonaws.com^$third-party";
+  const string test_url = "http://www.spark-public.s3.amazonaws.com/ads.txt";
+
+  // This should not result in a match, since the rule only applies to
+  // third party domains, and www.spark-public.s3.amazonaws.com
+  // and spark-public.s3.amazonaws.com are eTLD+1 equal (s3.amazonaws.com
+  // is a eTLD).
+  CHECK(testThirdPartyBlockingWithRulesDomainAndPublixSuffixList(
+    third_party_rule,
+    test_url,
+    "spark-public.s3.amazonaws.com",
+    public_suffix_rules,
+    "-ignored-",
+    false));
+
+  // This should match, since spark-public.s3.amazonaws.com
+  // and other.spark-public.s3.amazonaws.com are _not_ eTLD+1 (s3.amazonaws.com
+  // is a eTLD+1).
+  CHECK(testThirdPartyBlockingWithRulesDomainAndPublixSuffixList(
+    third_party_rule,
+    test_url,
+    "other.s3.amazonaws.com",
+    public_suffix_rules,
+    third_party_rule,
+    true));
+
+  // This should match, since the www.spark-public.s3.amazonaws.com
+  // and beans.amazonaws.com are not eTLD+1 (amazonaws.com is not a eTLD).
+  CHECK(testThirdPartyBlockingWithRulesDomainAndPublixSuffixList(
+    third_party_rule,
+    test_url,
+    "beans.amazonaws.com",
+    public_suffix_rules,
+    third_party_rule,
+    true));
+
+  // This should match, since the www.spark-public.s3.amazonaws.com
+  // and example.com are not eTLD+1 (amazonaws.com is not a eTLD).
+  CHECK(testThirdPartyBlockingWithRulesDomainAndPublixSuffixList(
+    third_party_rule,
+    test_url,
+    "example.com",
+    public_suffix_rules,
+    third_party_rule,
+    true));
+
+  // Last, add some non-matching rules, just to make sure we can still
+  // pick out correct rules.
+  CHECK(testThirdPartyBlockingWithRulesDomainAndPublixSuffixList(
+    third_party_rule + "\n||not-matching-anything.com\ntrees^",
+    test_url,
+    "example.com",
+    public_suffix_rules,
+    third_party_rule,
+    true));
+}
+
+bool testAdBlockSerializationWithPublicSuffixList(const string &rules,
+    const string &url, const string &domain, const string &public_suffix_list,
+    const string &expected_rule, bool should_match) {
+  AdBlockClient client;
+  client.parse(rules.c_str(), true);
+  client.parsePublicSuffixRules(public_suffix_list.c_str());
+
+  Filter matching_filter;
+  Filter *matching_ptr = &matching_filter;
+  Filter exception_filter;
+  Filter *exception_ptr = &exception_filter;
+
+  bool one_match = client.findMatchingFilters(url.c_str(), FONoFilterOption,
+    domain.c_str(), &matching_ptr, &exception_ptr);
+
+  // First make sure the first client behaves as expected.
+  if (one_match != should_match) {
+    std::cout << "Expected " << (should_match ? "a match" : "no match")
+              << " with the first client, but received "
+              << (one_match ? "a match" : "no match") << "." << std::endl;
+    return false;
+  }
+
+  if (should_match) {
+    bool is_expected_rule = strcmp(
+      matching_ptr->ruleDefinition, expected_rule.c_str()) == 0;
+    if (!is_expected_rule) {
+      std::cout << "Client one did not return the expected matching rule. "
+                << " Expected '" << expected_rule << "' but received '"
+                << matching_ptr->ruleDefinition << "'" << std::endl;
+      return false;
+    }
+  }
+
+  // And now build a second client from the de-serialized first, and make sure
+  // they behave the same way.
+  Filter matching_filter2;
+  Filter *matching_ptr2 = &matching_filter2;
+  Filter exception_filter2;
+  Filter *exception_ptr2 = &exception_filter2;
+
+  int size;
+  char* buffer = client.serialize(&size);
+
+  AdBlockClient client2;
+  client2.deserialize(buffer);
+
+  bool two_match = client2.findMatchingFilters(url.c_str(), FONoFilterOption,
+    domain.c_str(), &matching_ptr2, &exception_ptr2);
+
+  if (one_match != two_match) {
+    std::cout << "Client one matched the filter correctly, but client two "
+              << "returned " << (two_match ? "a match" : "no match")
+              << ". " << std::endl;
+    return false;
+  }
+
+  if (two_match) {
+    bool returned_rules_match = strncmp(matching_ptr->data,
+      matching_ptr2->data, matching_ptr->dataLen) == 0;
+    if (!returned_rules_match) {
+      std::cout << "Client two returned differnet rule data ("
+                << string(matching_ptr2->data, matching_ptr2->dataLen)
+                << ") from client one ("
+                << string(matching_ptr->data, matching_ptr->dataLen)
+                << ")." << std::endl;
+      return false;
+    }
+  }
+
+  return true;
+}
+
+TEST(etldSerializationTests, basic) {
+  std::ifstream ifs("./test/data/public_suffix_list.dat");
+  const string public_suffix_rules((std::istreambuf_iterator<char>(ifs)),
+                                   (std::istreambuf_iterator<char>()));
+  const string third_party_rule = "||s3.amazonaws.com^$third-party";
+  const string test_url = "http://www.spark-public.s3.amazonaws.com/ads.txt";
+
+  // This should not result in a match, since the rule only applies to
+  // third party domains, and www.spark-public.s3.amazonaws.com
+  // and spark-public.s3.amazonaws.com are eTLD+1 equal (s3.amazonaws.com
+  // is a eTLD).
+  CHECK(testAdBlockSerializationWithPublicSuffixList(
+    third_party_rule,
+    test_url,
+    "spark-public.s3.amazonaws.com",
+    public_suffix_rules,
+    "-ignored-",
+    false));
+
+  // This should match, since spark-public.s3.amazonaws.com
+  // and other.spark-public.s3.amazonaws.com are _not_ eTLD+1 (s3.amazonaws.com
+  // is a eTLD+1).
+  CHECK(testAdBlockSerializationWithPublicSuffixList(
+    third_party_rule,
+    test_url,
+    "other.s3.amazonaws.com",
+    public_suffix_rules,
+    third_party_rule,
+    true));
+
+  // This should match, since the www.spark-public.s3.amazonaws.com
+  // and beans.amazonaws.com are not eTLD+1 (amazonaws.com is not a eTLD).
+  CHECK(testAdBlockSerializationWithPublicSuffixList(
+    third_party_rule,
+    test_url,
+    "beans.amazonaws.com",
+    public_suffix_rules,
+    third_party_rule,
+    true));
+
+  // This should match, since the www.spark-public.s3.amazonaws.com
+  // and example.com are not eTLD+1 (amazonaws.com is not a eTLD).
+  CHECK(testAdBlockSerializationWithPublicSuffixList(
+    third_party_rule,
+    test_url,
+    "example.com",
+    public_suffix_rules,
+    third_party_rule,
+    true));
+
+  // Last, add some non-matching rules, just to make sure we can still
+  // pick out correct rules.
+  CHECK(testAdBlockSerializationWithPublicSuffixList(
+    third_party_rule + "\n||not-matching-anything.com\ntrees^",
+    test_url,
+    "example.com",
+    public_suffix_rules,
+    third_party_rule,
+    true));
+}
\ No newline at end of file
diff --git a/test/etld_serialization_test.cc b/test/etld_serialization_test.cc
new file mode 100644
index 0000000..520d27e
--- /dev/null
+++ b/test/etld_serialization_test.cc
@@ -0,0 +1,170 @@
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <string>
+#include <iostream>
+#include <vector>
+#include <set>
+#include <fstream>
+#include "./CppUnitLite/TestHarness.h"
+#include "./CppUnitLite/Test.h"
+#include "./ad_block_client.h"
+#include "./etld/types.h"
+#include "./etld/matcher.h"
+#include "./etld/parser.h"
+#include "./etld/domain.h"
+#include "./etld/public_suffix_rule.h"
+#include "./etld/public_suffix_rule_set.h"
+#include "./etld/serialization.h"
+
+using std::string;
+using std::vector;
+using brave_etld::PublicSuffixRule;
+using brave_etld::PublicSuffixRuleSet;
+using brave_etld::Matcher;
+using brave_etld::SerializationResult;
+using brave_etld::rule_from_serialization;
+using brave_etld::rule_set_from_serialization;
+using brave_etld::matcher_from_serialization;
+using brave_etld::SerializedBuffer;
+
+bool testSerializeRule(const string &rule_text) {
+  PublicSuffixRule rule(rule_text);
+  SerializationResult res = rule.Serialize();
+  PublicSuffixRule second_rule = rule_from_serialization(res.buffer);
+  return rule.Equals(second_rule);
+}
+
+TEST(eTLDSerializationSingleRule, basic) {
+  CHECK(testSerializeRule("example.com"));
+  CHECK(testSerializeRule("www.example.com"));
+  CHECK(testSerializeRule("*.example.com"));
+  CHECK(testSerializeRule("!tree.example.com"));
+}
+
+bool testSerializeRuleSet(const vector<PublicSuffixRule> &rules) {
+  PublicSuffixRuleSet rule_set(rules);
+  SerializationResult res = rule_set.Serialize();
+  PublicSuffixRuleSet second_set = rule_set_from_serialization(res.buffer);
+  return rule_set.Equal(second_set);
+}
+
+TEST(eTLDSerializationRuleSet, basic) {
+  CHECK(testSerializeRuleSet({PublicSuffixRule("!one.com")}));
+  CHECK(testSerializeRuleSet({
+    PublicSuffixRule("!one.com"), PublicSuffixRule("*.two.com")}));
+  CHECK(testSerializeRuleSet({
+    PublicSuffixRule("!one.com"), PublicSuffixRule("*.two.com"),
+    PublicSuffixRule("three.com")}));
+}
+
+bool testSerializeMatcher(const string &rule_text) {
+  Matcher orig(rule_text);
+  SerializationResult res = orig.Serialize();
+  Matcher second = matcher_from_serialization(res.buffer);
+  return orig.Equal(second);
+}
+
+TEST(eTLDSerializationMatcher, basic) {
+  CHECK(testSerializeMatcher("!one.com"));
+  CHECK(testSerializeMatcher("!one.com\n*.two.com"));
+  CHECK(testSerializeMatcher("!one.com\n*.two.com\nthree.com"));
+}
+
+bool testDeserializationCorrectness(const SerializedBuffer &rule_text,
+    int num_rules, int num_exception_rules) {
+  Matcher matcher = matcher_from_serialization(rule_text);
+  int num_matcher_rules = static_cast<int>(matcher.NumRules());
+  if (num_matcher_rules != num_rules) {
+    std::cout << "Expected " << num_rules << " rules from buffer, but received "
+              << num_matcher_rules << " rules." << std::endl;
+    return false;
+  }
+
+  int num_matcher_except_rules = static_cast<int>(matcher.NumExceptionRules());
+  if (num_matcher_except_rules != num_exception_rules) {
+    std::cout << "Expected " << num_rules << " exception rules from buffer, "
+              << "but received " <<  num_exception_rules << " rules."
+              << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
+// TEST(eTLDDeserializationTests, basic) {
+//   CHECK(testDeserializationCorrectness(
+//     "47:42:29:ff||not-matching-anything.com8:fftrees^0:", 2, 0));
+// }
+
+bool testSerializationCorrectness(const string &rule_text,
+    const SerializedBuffer &serialized) {
+  Matcher matcher(rule_text);
+  SerializationResult result = matcher.Serialize();
+  return result.buffer.compare(serialized) == 0;
+}
+
+// TEST(eTLDSerializationTests, basic) {
+//   const string rules = "||s3.amazonaws.com^$third-party\n"
+//                        "||not-matching-anything.com\n"
+//                        "trees^";
+//   CHECK(testSerializationCorrectness(rules, ));
+// }
+
+bool testMatcherSerializationTransitivity(const string &public_suffix_rules) {
+  Matcher orig(public_suffix_rules);
+  SerializationResult res = orig.Serialize();
+
+  Matcher second = matcher_from_serialization(res.buffer);
+  SerializationResult res2 = second.Serialize();
+
+  if (res2.buffer.compare(res.buffer) != 0) {
+    std::cout << "The serialized buffer of the initial Matcher does not match "
+              << "the serialized of the second, buffer initialized buffer."
+              << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
+bool testAdBlockClientSerializationTransitivity(const string &filter_rules,
+    const string &public_suffix_rules) {
+  AdBlockClient client;
+  client.parse(filter_rules.c_str());
+  client.parsePublicSuffixRules(public_suffix_rules.c_str());
+  
+  int size;
+  char* buffer = client.serialize(&size);
+
+  AdBlockClient client2;
+  client2.deserialize(buffer);
+  int size2;
+  char* buffer2 = client2.serialize(&size2);
+
+  if (size != size2) {
+    std::cout << "The size of the serialized buffers of the first and second "
+              << "client do not match." << std::endl;
+    return false;
+  }
+
+  if (strncmp(buffer, buffer2, size) != 0) {
+    std::cout << "The serialized buffers of the first and second client do "
+              << "not have the same contents." << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
+TEST(eTLDSerializationTransitivity, basic) {
+  std::ifstream ifs("./test/data/public_suffix_list_short.txt");
+  const string public_suffix_rules((std::istreambuf_iterator<char>(ifs)),
+                                   (std::istreambuf_iterator<char>()));
+  const string filer_rules = "||not-matching-anything.com\ntrees^";
+  CHECK(testMatcherSerializationTransitivity(public_suffix_rules));
+  CHECK(testAdBlockClientSerializationTransitivity(
+    filer_rules, public_suffix_rules));
+}
\ No newline at end of file
diff --git a/test/etld_test.cc b/test/etld_test.cc
index 5805585..0ec0bbb 100644
--- a/test/etld_test.cc
+++ b/test/etld_test.cc
@@ -1,31 +1,546 @@
-/* Copyright (c) 2015 Brian R. Bondy. Distributed under the MPL2 license.
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include <string>
 #include <iostream>
+#include <vector>
 #include <set>
+#include <fstream>
 #include "./CppUnitLite/TestHarness.h"
 #include "./CppUnitLite/Test.h"
-#include "./etld.h"
+#include "./etld/types.h"
+#include "./etld/matcher.h"
+#include "./etld/parser.h"
+#include "./etld/domain.h"
+#include "./etld/public_suffix_rule.h"
+#include "./etld/public_suffix_rule_set.h"
 
 using std::string;
 using std::cout;
 using std::endl;
 
-using Brave::eTLD::PublicSuffixTextLineType;
-using Brave::eTLD::PublicSuffixTextLineParseResult;
+using brave_etld::PublicSuffixTextLineType;
+using brave_etld::PublicSuffixTextLineParseResult;
+using brave_etld::PublicSuffixRuleInputException;
+using brave_etld::PublicSuffixRuleSetMatchResult;
+using brave_etld::PublicSuffixRule;
+using brave_etld::PublicSuffixRuleSet;
+using brave_etld::Domain;
+using brave_etld::Matcher;
+using brave_etld::DomainInfo;
+using brave_etld::PublicSuffixParseResult;
+using brave_etld::parse_rule_line;
+using brave_etld::parse_rule_text;
+using brave_etld::parse_rule_file;
 
-bool testParsePublicSuffixTestLineType(const char * line, PublicSuffixTextLineType expectedType) {
-  PublicSuffixTextLineParseResult result = Brave::eTLD::parse_public_suffix_text_line(string(line));
-  return (result.type() == expectedType);
+
+bool testParsePublicSuffixTestLineNoOps(const string &line,
+    PublicSuffixTextLineType expectedType) {
+  PublicSuffixTextLineParseResult result = parse_rule_line(line);
+  if (result.type != expectedType) {
+    cout << "Received unexpected parse result for " << line << endl;
+    return false;
+  }
+
+  return true;
+}
+
+bool testParsePublicSuffixTestLineError(const string &line,
+    const string &expected_error) {
+  try {
+    PublicSuffixRule rule(line);
+  } catch (PublicSuffixRuleInputException error) {
+    string error_string(error.what());
+    size_t error_substr_pos = error_string.find_first_of(expected_error);
+    if (error_substr_pos == string::npos) {
+      cout << "Caught an unexpected error when parsing " << line << "\n"
+           << "Expected '" << expected_error << "'\n"
+           << "Received '" << error.what() << endl;
+      return false;
+    }
+    return true;
+  }
+
+  cout << "Expected to receive an error when attempting to parse invalid rule '"
+       << line
+       << "' but no error was thrown." << endl;
+  return false;
+}
+
+bool testParsePublicSuffixTest(
+    const string &line,
+    std::vector<string> expected_labels,
+    bool expected_exception,
+    bool expected_wildcard) {
+  PublicSuffixRule rule(line);
+  PublicSuffixRule currect_rule(expected_labels, expected_exception,
+    expected_wildcard);
+  return currect_rule.Equals(rule);
+}
+
+bool _verifyParsePublicSuffixTest(
+    PublicSuffixParseResult result,
+    int num_expected_rules,
+    int num_expected_exception_rules,
+    int num_expected_wildcard_rules,
+    int num_expected_whitespace_lines,
+    int num_expected_comment_lines,
+    int num_expected_invalid_lines) {
+  if (num_expected_rules != result.Rules().size()) {
+    cout << "Incorrect num of rules parsed, expected '"
+         << num_expected_rules << "' "
+         << "but found '" << result.Rules().size() << "'" << endl;
+    return false;
+  }
+
+  int num_found_exception_rules = 0;
+  int num_found_wildcard_rules = 0;
+  for (auto &elm : result.Rules()) {
+    if (elm.IsException()) {
+      num_found_exception_rules += 1;
+    }
+    if (elm.IsWildcard()) {
+      num_found_wildcard_rules += 1;
+    }
+  }
+
+  if (num_found_exception_rules != num_expected_exception_rules) {
+    cout << "Found unexpected number of exception rules, expected '"
+         << num_expected_exception_rules << "' "
+         << "but found '" << num_found_exception_rules << "'" << endl;
+    return false;
+  }
+
+  if (num_found_exception_rules != num_expected_exception_rules) {
+    cout << "Found unexpected number of exception rules, expected '"
+         << num_expected_exception_rules << "' "
+         << "but found '" << num_found_exception_rules << "'" << endl;
+    return false;
+  }
+
+  if (result.NumWhitespaceLines() != num_expected_whitespace_lines) {
+    cout << "Found unexpected number of whitespace lines, expected '"
+         << num_expected_whitespace_lines << "' "
+         << "but found '" << result.NumWhitespaceLines() << "'" << endl;
+    return false;
+  }
+
+  if (result.NumInvalidRules() != num_expected_invalid_lines) {
+    cout << "Found unexpected number of invalid rules, expected '"
+         << num_expected_invalid_lines << "' "
+         << "but found '" << result.NumInvalidRules() << "'" << endl;
+    return false;
+  }
+
+  if (result.NumCommentLines() != num_expected_comment_lines) {
+    cout << "Found unexpected number of comment lines, expected '"
+         << num_expected_comment_lines << "' "
+         << "but found '" << result.NumCommentLines() << "'" << endl;
+    return false;
+  }
+
+  return true;
 }
 
-TEST(publicSuffixTest, basic) {
-  CHECK(testParsePublicSuffixTestLineType(
-      "// this is an option",
-      Brave::eTLD::PublicSuffixTextLineTypeStandard
-    )
-  );
+bool testParsePublicSuffixTextTest(
+    const string &text,
+    int num_expected_rules,
+    int num_expected_exception_rules,
+    int num_expected_wildcard_rules,
+    int num_expected_whitespace_lines,
+    int num_expected_comment_lines,
+    int num_expected_invalid_lines) {
+  PublicSuffixParseResult result = parse_rule_text(text);
+  return _verifyParsePublicSuffixTest(
+    result,
+    num_expected_rules,
+    num_expected_exception_rules,
+    num_expected_wildcard_rules,
+    num_expected_whitespace_lines,
+    num_expected_comment_lines,
+    num_expected_invalid_lines);
 }
+
+bool testParsePublicSuffixFileTest(
+    const string &file_path,
+    int num_expected_rules,
+    int num_expected_exception_rules,
+    int num_expected_wildcard_rules,
+    int num_expected_whitespace_lines,
+    int num_expected_comment_lines,
+    int num_expected_invalid_lines) {
+  std::ifstream rule_file;
+  rule_file.open(file_path, std::ifstream::in);
+  PublicSuffixParseResult result = parse_rule_file(rule_file);
+  return _verifyParsePublicSuffixTest(
+    result,
+    num_expected_rules,
+    num_expected_exception_rules,
+    num_expected_wildcard_rules,
+    num_expected_whitespace_lines,
+    num_expected_comment_lines,
+    num_expected_invalid_lines);
+}
+
+bool testMatchingDomainRules(const string &rule_str, const string &domain_str,
+    bool should_match) {
+  Domain domain(domain_str);
+  PublicSuffixRule rule(rule_str);
+
+  bool does_match = rule.Matches(domain);
+  if (should_match != does_match) {
+    string desc(should_match
+      ? "should have, but didn't match "
+      : "didn't, but should have matched ");
+    cout << "Domain: '" << domain.ToString() << "' "
+         << desc
+         << "Rule: '" << rule.ToString() << "'" << endl;
+    return false;
+  }
+
+  return true;
+}
+
+bool testPublicSuffixRuleSetMatch(const std::vector<string> &rules,
+    const string &domain_str, const string &expected_match) {
+  PublicSuffixRuleSet rule_set;
+  PublicSuffixRule rule;
+  for (auto &elm : rules) {
+    rule = PublicSuffixRule(elm);
+    rule_set.AddRule(rule);
+  }
+
+  Domain test_domain(domain_str);
+  PublicSuffixRuleSetMatchResult match_result = rule_set.Match(test_domain);
+  string result_string = match_result.rule.DomainString();
+  if (result_string != expected_match) {
+    cout << "Expected rule: '" << expected_match << "' "
+         << "to match '" << domain_str << "' "
+         << "but received '" << result_string << "'" << endl;
+    return false;
+  }
+
+  return true;
+}
+
+bool testPublicSuffixRuleTextApply(const string &rule_str,
+    const string &domain_str, const DomainInfo &expected) {
+  PublicSuffixRule rule(rule_str);
+  Domain domain(domain_str);
+  DomainInfo extracted = rule.Apply(domain);
+  if (extracted.tld != expected.tld) {
+    cout << "Expected tld of '" << expected.tld
+         << "' when applying rule '"
+         << rule_str << "' to domain '" << domain_str
+         << "', but received tld '" << extracted.tld << "'" << endl;
+    return false;
+  }
+
+  if (extracted.domain != expected.domain) {
+    cout << "Expected domain of '" << expected.domain
+         << "' when applying rule '"
+         << rule_str << "' to domain '" << domain_str
+         << "', but received domain '"
+         << extracted.domain << "'" << endl;
+    return false;
+  }
+
+  if (extracted.subdomain != expected.subdomain) {
+    cout << "Expected subdomain of '" << expected.subdomain
+         << "' when applying rule '"
+         << rule_str << "' to domain '" << domain_str
+         << "', but received subdomain '"
+         << extracted.subdomain << "'" << endl;
+    return false;
+  }
+
+  return true;
+}
+
+bool testPublicSuffixRuleFileApply(const string &file_path,
+    const string &domain_str, const DomainInfo &expected) {
+  std::ifstream rule_file;
+  rule_file.open(file_path, std::ifstream::in);
+  Matcher matcher(rule_file);
+  DomainInfo extracted = matcher.Match(Domain(domain_str));
+
+  if (extracted.tld != expected.tld) {
+    cout << "Expected tld of '" << expected.tld
+         << "' when applying file '"
+         << file_path << "' to domain '" << domain_str
+         << "', but received tld '" << extracted.tld << "'" << endl;
+    return false;
+  }
+
+  if (extracted.domain != expected.domain) {
+    cout << "Expected domain of '" << expected.domain
+         << "' when applying file '"
+         << file_path << "' to domain '" << domain_str
+         << "', but received domain '" << extracted.domain << "'" << endl;
+    return false;
+  }
+
+  if (extracted.subdomain != expected.subdomain) {
+    cout << "Expected subdomain of '" << expected.subdomain
+         << "' when applying file '"
+         << file_path << "' to domain '" << domain_str
+         << "', but received subdomain '" << extracted.subdomain << "'" << endl;
+    return false;
+  }
+
+  return true;
+}
+
+TEST(eTLDParseRulesLine, basic) {
+  CHECK(testParsePublicSuffixTestLineNoOps(
+    "// this is an option",
+    brave_etld::PublicSuffixTextLineTypeComment));
+
+  CHECK(testParsePublicSuffixTestLineNoOps(
+    "this.is.a.invalid..rule",
+    brave_etld::PublicSuffixTextLineTypeInvalidRule));
+
+  CHECK(testParsePublicSuffixTestLineNoOps(
+    "",
+    brave_etld::PublicSuffixTextLineTypeWhitespace));
+
+  // Since we read until the first white space, this will be read
+  // as "example.", which is invalid because rules cannot hae empty labels
+  CHECK(testParsePublicSuffixTestLineError(
+    "example. org",
+    "Rules cannot end with a delimiter"));
+  CHECK(testParsePublicSuffixTestLineError(
+    "example..org",
+    "Rules cannot contain adjectent delimitors"));
+  CHECK(testParsePublicSuffixTestLineError(
+    "example.org.",
+    "Rules cannot end with a delimiter"));
+
+  // Examples taken from https://publicsuffix.org/list/
+  CHECK(testParsePublicSuffixTest(
+    "com",
+    {"com"},
+    false,
+    false));
+  CHECK(testParsePublicSuffixTest(
+    "*.jp",
+    {"*", "jp"},
+    false,
+    true));
+  CHECK(testParsePublicSuffixTest(
+    "*.jp",
+    {"*", "jp"},
+    false,
+    true));
+  CHECK(testParsePublicSuffixTest(
+    "*.tokyo.jp",
+    {"*", "tokyo", "jp"},
+    false,
+    true));
+  CHECK(testParsePublicSuffixTest(
+    "!pref.hokkaido.jp",
+    {"pref", "hokkaido", "jp"},
+    true,
+    false));
+}
+
+TEST(eTLDParseRulesText, basic) {
+  // Just retesting the examples from above, to make sure they are parsed
+  // correctly when all in a line.
+  CHECK(testParsePublicSuffixTextTest(
+    "com\n*.jp\n*.jp\n*.tokyo.jp\n!pref.hokkaido.jp",
+    5, 1, 3, 0, 0, 0));
+
+  CHECK(testParsePublicSuffixTextTest(
+    "// ac : https://en.wikipedia.org/wiki/.ac\n"
+    "ac\n"
+    "com.ac\n"
+    "edu.ac\n"
+    "gov.ac\n"
+    "net.ac\n"
+    "mil.ac\n"
+    "org.ac\n",
+    7, 0, 0, 0, 1, 0));
+  CHECK(testParsePublicSuffixTextTest(
+    "// am : https://en.wikipedia.org/wiki/.am\n"
+    "am\n"
+    "\n"
+    "// ao : https://en.wikipedia.org/wiki/.ao \n"
+    "// http://www.dns.ao/REGISTR.DOC \n"
+    "ao\n"
+    "ed.ao\n"
+    "gv.ao\n"
+    "og.ao\n"
+    "co.ao\n"
+    "pb.ao\n"
+    "it.ao\n",
+    8, 0, 0, 1, 3, 0));
+  CHECK(testParsePublicSuffixTextTest(
+    "\n"
+    "*.wild.rule\n"
+    "!exception.rule \n"
+    "// coment line \n"
+    "example.org\n"
+    "...badrule",
+    3, 1, 1, 1, 1, 1));
+}
+
+TEST(eTLDParseRulesFile, basic) {
+  CHECK(testParsePublicSuffixFileTest(
+    "./test/data/public_suffix_list_short.txt",
+    32, 1, 1, 8, 12, 0));
+}
+
+TEST(eTLDMatchTests, basic) {
+  CHECK(testMatchingDomainRules("com", "com", true));
+  CHECK(testMatchingDomainRules("fp.com", "com", false));
+  CHECK(testMatchingDomainRules("com", "fp.com", true));
+  CHECK(testMatchingDomainRules("*.hokkaido.jp", "bar.hokkaido.jp", true));
+  CHECK(testMatchingDomainRules("!pref.hokkaido.jp", "pref.hokkaido.jp", true));
+  CHECK(testMatchingDomainRules("*.tokyo.jp", "tokyo.jp", false));
+  CHECK(testMatchingDomainRules("*.tokyo.jp", "other.tokyo.jp", true));
+  CHECK(testMatchingDomainRules("com", "foo.com", true));
+}
+
+TEST(eTLDPublicSuffixRuleSetMatchTests, basic) {
+  CHECK(testPublicSuffixRuleSetMatch(
+    {"com", "*.jp", "*.hokkaido.jp"},
+    "foo.com",
+    "com"));
+  CHECK(testPublicSuffixRuleSetMatch(
+    {"com", "*.jp", "*.hokkaido.jp"},
+    "hokkaido.jp",
+    "*.jp"));
+  CHECK(testPublicSuffixRuleSetMatch(
+    {"com", "*.jp", "*.hokkaido.jp"},
+    "pete.hokkaido.jp",
+    "*.hokkaido.jp"));
+  CHECK(testPublicSuffixRuleSetMatch(
+    {"com", "*.jp", "*.hokkaido.jp"},
+    "horse.shoes",
+    ""));
+}
+
+TEST(eTLDPublicSuffixRuleApplyTestTests, basic) {
+  DomainInfo test_one_expected_match = {"example.jp", "shoes", "pete"};
+  CHECK(testPublicSuffixRuleTextApply(
+    "*.jp", "pete.shoes.example.jp", test_one_expected_match));
+
+  DomainInfo test_two_expected_match = {"horse", "the", "we.love"};
+  CHECK(testPublicSuffixRuleTextApply(
+      "horse", "we.love.the.horse", test_two_expected_match));
+
+  DomainInfo test_three_expected_match = {"tokyo.jp", "metro", "slate"};
+  CHECK(testPublicSuffixRuleTextApply(
+      "!metro.tokyo.jp", "slate.metro.tokyo.jp", test_three_expected_match));
+}
+
+TEST(eTLDPublicSuffixRuleApplyFileTests, basic) {
+  DomainInfo file_test_one = {"com", "google", "www"};
+  CHECK(testPublicSuffixRuleFileApply(
+    "./test/data/public_suffix_list.dat",
+    "www.google.com",
+    file_test_one));
+
+  DomainInfo file_test_two = {"co.uk", "google", ""};
+  CHECK(testPublicSuffixRuleFileApply(
+    "./test/data/public_suffix_list.dat",
+    "google.co.uk",
+    file_test_two));
+
+  // Tests taken from https://www.npmjs.com/package/tldts
+  DomainInfo file_test_three = {"s3.amazonaws.com", "spark-public", ""};
+  CHECK(testPublicSuffixRuleFileApply(
+    "./test/data/public_suffix_list.dat",
+    "spark-public.s3.amazonaws.com",
+    file_test_three));
+
+  DomainInfo file_test_four = {"org", "writethedocs", "www"};
+  CHECK(testPublicSuffixRuleFileApply(
+    "./test/data/public_suffix_list.dat",
+    "www.writethedocs.org",
+    file_test_four));
+
+  // Tests taken from https://www.npmjs.com/package/tld
+  DomainInfo file_test_five = {"bar.sch.uk", "foo", "www"};
+  CHECK(testPublicSuffixRuleFileApply(
+    "./test/data/public_suffix_list.dat",
+    "www.foo.bar.sch.uk",
+    file_test_five));
+
+  // Tests taken from https://www.npmjs.com/package/parse-domain
+  DomainInfo file_test_six = {"co.uk", "example", "some.subdomain"};
+  CHECK(testPublicSuffixRuleFileApply(
+    "./test/data/public_suffix_list.dat",
+    "some.subdomain.example.co.uk",
+    file_test_six));
+
+  // Tests adapted from
+  // https://raw.githubusercontent.com/publicsuffix/list/master/tests/test_psl.txt
+  struct DomainInfoTestCase {
+    string input;
+    DomainInfo expected;
+  };
+  DomainInfoTestCase file_test_cases[] = {
+    {"com", {"com", "", ""}},
+    {"example.com", {"com", "example", ""}},
+    {"www.example.com", {"com", "example", "www"}},
+    {"example", {"example", "", ""}},
+    {"example.example", {"example", "example", ""}},
+    {"b.example.example", {"example", "example", "b"}},
+    {"a.b.example.example", {"example", "example", "a.b"}},
+    {"biz", {"biz", "", ""}},
+    {"domain.biz", {"biz", "domain", ""}},
+    {"b.domain.biz", {"biz", "domain", "b"}},
+    {"uk.com", {"uk.com", "", ""}},
+    {"example.uk.com", {"uk.com", "example", ""}},
+    {"b.example.uk.com", {"uk.com", "example", "b"}},
+    {"a.b.example.uk.com", {"uk.com", "example", "a.b"}},
+    {"jp", {"jp", "", ""}},
+    {"test.jp", {"jp", "test", ""}},
+    {"www.test.jp", {"jp", "test", "www"}},
+    {"ac.jp", {"ac.jp", "", ""}},
+    {"test.ac.jp", {"ac.jp", "test", ""}},
+    {"www.test.ac.jp", {"ac.jp", "test", "www"}},
+    {"kyoto.jp", {"kyoto.jp", "", ""}},
+    {"test.kyoto.jp", {"kyoto.jp", "test", ""}},
+    {"ide.kyoto.jp", {"ide.kyoto.jp", "", ""}},
+    {"b.ide.kyoto.jp", {"ide.kyoto.jp", "b", ""}},
+    {"a.b.ide.kyoto.jp", {"ide.kyoto.jp", "b", "a"}},
+    {"c.kobe.jp", {"c.kobe.jp", "", ""}},
+    {"b.c.kobe.jp", {"c.kobe.jp", "b", ""}},
+    {"a.b.c.kobe.jp", {"c.kobe.jp", "b", "a"}},
+    {"city.kobe.jp", {"kobe.jp", "city", ""}},
+    {"www.city.kobe.jp", {"kobe.jp", "city", "www"}},
+    {"ck", {"ck", "", ""}},
+    {"test.ck", {"test.ck", "", ""}},
+    {"b.test.ck", {"test.ck", "b", ""}},
+    {"a.b.test.ck", {"test.ck", "b", "a"}},
+    {"www.ck", {"ck", "www", ""}},
+    {"www.www.ck", {"ck", "www", "www"}},
+    {"us", {"us", "", ""}},
+    {"test.us", {"us", "test", ""}},
+    {"www.test.us", {"us", "test", "www"}},
+    {"ak.us", {"ak.us", "", ""}},
+    {"test.ak.us", {"ak.us", "test", ""}},
+    {"www.test.ak.us", {"ak.us", "test", "www"}},
+    {"k12.ak.us", {"k12.ak.us", "", ""}},
+    {"test.k12.ak.us", {"k12.ak.us", "test", ""}},
+    {"www.test.k12.ak.us", {"k12.ak.us", "test", "www"}},
+    {"食狮.com.cn", {"com.cn", "食狮", ""}},
+    {"食狮.公司.cn", {"公司.cn", "食狮", ""}},
+    {"sushi.公司.cn", {"公司.cn", "sushi", ""}},
+    {"公司.cn", {"公司.cn", "", ""}},
+    {"食狮.中国", {"中国", "食狮", ""}},
+    {"shishi.中国", {"中国", "shishi", ""}},
+    {"中国", {"中国", "", ""}},
+  };
+  for (auto &elm : file_test_cases) {
+    CHECK(testPublicSuffixRuleFileApply(
+      "./test/data/public_suffix_list.dat",
+      elm.input,
+      elm.expected));
+  }
+}
\ No newline at end of file
diff --git a/test/js/etldTest.js b/test/js/etldTest.js
new file mode 100644
index 0000000..d1b1ee0
--- /dev/null
+++ b/test/js/etldTest.js
@@ -0,0 +1,85 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+/* global describe, it, before */
+
+const fs = require('fs')
+const assert = require('assert')
+const {AdBlockClient, FilterOptions} = require('../..')
+
+describe('etld+1 matching', function () {
+  describe('third-party checking', function () {
+    before(function () {
+      const etldRules = fs.readFileSync('./test/data/public_suffix_list.dat', 'utf8')
+      this.client = new AdBlockClient()
+      this.client.parse('||s3.amazonaws.com^$third-party\n||not-matching-anything.com\ntrees^')
+      this.client.parsePublicSuffixRules(etldRules)
+    })
+
+    it('do not apply third-party rules when domains are etld+1', function () {
+      const result = this.client.findMatchingFilters(
+        "http://www.spark-public.s3.amazonaws.com/ads.js",
+        FilterOptions.script,
+        "other.s3.amazonaws.com"
+      );
+      assert(result.matches, false)
+    })
+
+    it('apply third-party rules when domains are similar but not etld+1', function () {
+      const result = this.client.findMatchingFilters(
+        "http://www.spark-public.s3.amazonaws.com/ads.js",
+        FilterOptions.script,
+        "example.amazonaws.com"
+      );
+      assert(result.matches, true)
+    })
+
+    it('apply third-party rules when domains are not similar at all', function () {
+      const result = this.client.findMatchingFilters(
+        "http://www.spark-public.s3.amazonaws.com/ads.js",
+        FilterOptions.script,
+        "example.org"
+      );
+      assert(result.matches, true)
+    })
+  })
+
+  describe('after serialization', function () {
+    before(function () {
+      const etldRules = fs.readFileSync('./test/data/public_suffix_list.dat', 'utf8')
+      this.client = new AdBlockClient()
+      this.client.parse('||s3.amazonaws.com^$third-party\n||not-matching-anything.com\ntrees^')
+      this.client.parsePublicSuffixRules(etldRules)
+
+      this.client2 = new AdBlockClient()
+      this.client2.deserialize(this.client.serialize())
+    })
+
+    it('do not apply third-party rules when domains are etld+1', function () {
+      const result = this.client2.findMatchingFilters(
+        "http://www.spark-public.s3.amazonaws.com/ads.js",
+        FilterOptions.script,
+        "other.s3.amazonaws.com"
+      );
+      assert(result.matches, false)
+    })
+
+    it('apply third-party rules when domains are similar but not etld+1', function () {
+      const result = this.client2.findMatchingFilters(
+        "http://www.spark-public.s3.amazonaws.com/ads.js",
+        FilterOptions.script,
+        "example.amazonaws.com"
+      );
+      assert(result.matches, true)
+    })
+
+    it('apply third-party rules when domains are not similar at all', function () {
+      const result = this.client2.findMatchingFilters(
+        "http://www.spark-public.s3.amazonaws.com/ads.js",
+        FilterOptions.script,
+        "example.org"
+      );
+      assert(result.matches, true)
+    })
+  })
+})
\ No newline at end of file
diff --git a/test/js/matchingTest.js b/test/js/matchingTest.js
index 9645549..fb0ad3c 100644
--- a/test/js/matchingTest.js
+++ b/test/js/matchingTest.js
@@ -3,6 +3,7 @@
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 /* global describe, before, it */
 
+const fs = require('fs')
 const assert = require('assert')
 const {AdBlockClient} = require('../..')
 const {FilterOptions} = require('../..')
@@ -460,6 +461,8 @@ describe('matching', function () {
     before(function () {
       this.client = new AdBlockClient()
       this.client.parse('||bannersnack.com^$third-party')
+      const etldRules = fs.readFileSync('./test/data/public_suffix_list.dat', 'utf8')
+      this.client.parsePublicSuffixRules(etldRules)
     })
     it('consider eTLD+1 domains as 1p', function () {
       const altSubDomainQuery = this.client.findMatchingFilters(
diff --git a/test/protocol_test.cc b/test/protocol_test.cc
index b68336a..e9f025a 100644
--- a/test/protocol_test.cc
+++ b/test/protocol_test.cc
@@ -42,8 +42,8 @@ TEST(isBlockableProtocol, basic) {
   // Each of the following should fail, since they are each non supported /
   // blockable protocols.
 
-  // To short example
-  CHECK(isBlockableProtocol("htt", 3) == true);
+  // Too short example
+  CHECK(isBlockableProtocol("htt", 3) == false);
 
   // Bad protocol example.
   CHECK(isBlockableProtocol("htttp://example.com", 25) == false);

From 3d9051150f06b2e8a83ca92b7d295f07c3bc2824 Mon Sep 17 00:00:00 2001
From: Peter Snyder <snyderp@gmail.com>
Date: Thu, 21 Feb 2019 22:16:14 -0800
Subject: [PATCH 03/13] linter fixes

---
 etld/matcher.cc                 |  4 +--
 etld/matcher.h                  |  3 ++-
 etld/parser.cc                  |  3 ---
 etld/public_suffix_rule.cc      |  5 +---
 etld/public_suffix_rule.h       |  2 --
 etld/public_suffix_rule_set.cc  |  6 +----
 etld/public_suffix_rule_set.h   |  3 ---
 protocol.cc                     |  2 +-
 test/etld_serialization_test.cc | 44 ++-------------------------------
 test/etld_test.cc               |  2 +-
 test/parser_test.cc             |  6 +++--
 11 files changed, 13 insertions(+), 67 deletions(-)

diff --git a/etld/matcher.cc b/etld/matcher.cc
index 3d0b80a..fde03ca 100644
--- a/etld/matcher.cc
+++ b/etld/matcher.cc
@@ -9,7 +9,6 @@
 #include "etld/parser.h"
 #include "etld/public_suffix_rule.h"
 #include "etld/matcher.h"
-#include "etld/types.h"
 #include "etld/serialization.h"
 
 namespace brave_etld {
@@ -53,8 +52,7 @@ SerializationResult Matcher::Serialize() const {
     buffer_size,
     "%s:%s",
     header_str.c_str(),
-    buffer_body.c_str()
-  );
+    buffer_body.c_str());
 
   SerializationResult info;
   info.body_start = body_start;
diff --git a/etld/matcher.h b/etld/matcher.h
index a706816..6a9b59d 100644
--- a/etld/matcher.h
+++ b/etld/matcher.h
@@ -25,7 +25,8 @@ class Matcher {
   explicit Matcher(std::ifstream &rule_file);
   explicit Matcher(const std::string &rule_text);
   explicit Matcher(const PublicSuffixParseResult &rules);
-  Matcher(const PublicSuffixRuleSet &rules, const PublicSuffixRuleSet &exception_rules);
+  Matcher(const PublicSuffixRuleSet &rules,
+    const PublicSuffixRuleSet &exception_rules);
 
   SerializationResult Serialize() const;
 
diff --git a/etld/parser.cc b/etld/parser.cc
index 0cd9b70..3f421f8 100644
--- a/etld/parser.cc
+++ b/etld/parser.cc
@@ -3,7 +3,6 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#include <memory>
 #include <string>
 #include <sstream>
 #include <fstream>
@@ -12,8 +11,6 @@
 #include "etld/public_suffix_rule.h"
 #include "etld/types.h"
 
-using std::unique_ptr;
-
 namespace brave_etld {
 
 PublicSuffixParseResult::PublicSuffixParseResult() {}
diff --git a/etld/public_suffix_rule.cc b/etld/public_suffix_rule.cc
index 4f83844..94932eb 100644
--- a/etld/public_suffix_rule.cc
+++ b/etld/public_suffix_rule.cc
@@ -13,8 +13,6 @@
 #include "etld/types.h"
 #include "etld/serialization.h"
 
-using std::unique_ptr;
-
 namespace brave_etld {
 
 std::vector<Label> parse_labels(const std::string &label_text) {
@@ -125,8 +123,7 @@ SerializationResult PublicSuffixRule::Serialize() const {
     header_str.c_str(),
     is_exception_ ? 't' : 'f',
     is_wildcard_ ? 't' : 'f',
-    domain_string.c_str()
-  );
+    domain_string.c_str());
 
   info.body_start = body_start;
   info.body_len = body_len;
diff --git a/etld/public_suffix_rule.h b/etld/public_suffix_rule.h
index 7739548..fc259d9 100644
--- a/etld/public_suffix_rule.h
+++ b/etld/public_suffix_rule.h
@@ -12,8 +12,6 @@
 #include "etld/types.h"
 #include "etld/serialization.h"
 
-using std::unique_ptr;
-
 namespace brave_etld {
 
 class PublicSuffixRuleInputException : public std::exception {
diff --git a/etld/public_suffix_rule_set.cc b/etld/public_suffix_rule_set.cc
index c685553..97fd2c5 100644
--- a/etld/public_suffix_rule_set.cc
+++ b/etld/public_suffix_rule_set.cc
@@ -6,7 +6,6 @@
 #include <string>
 #include <sstream>
 #include <vector>
-#include <memory>
 #include <iostream>
 #include "etld/public_suffix_rule.h"
 #include "etld/public_suffix_rule_set.h"
@@ -14,8 +13,6 @@
 #include "etld/types.h"
 #include "etld/serialization.h"
 
-using std::unique_ptr;
-
 namespace brave_etld {
 
 PublicSuffixRuleSet::PublicSuffixRuleSet() {}
@@ -70,8 +67,7 @@ SerializationResult PublicSuffixRuleSet::Serialize() const {
     buffer_size,
     "%s:%s",
     header_str.c_str(),
-    buffer_body.c_str()
-  );
+    buffer_body.c_str());
 
   SerializationResult info;
   info.body_start = body_start;
diff --git a/etld/public_suffix_rule_set.h b/etld/public_suffix_rule_set.h
index 47aa47a..95e8a20 100644
--- a/etld/public_suffix_rule_set.h
+++ b/etld/public_suffix_rule_set.h
@@ -8,14 +8,11 @@
 
 #include <string>
 #include <vector>
-#include <memory>
 #include "etld/public_suffix_rule.h"
 #include "etld/domain.h"
 #include "etld/types.h"
 #include "etld/serialization.h"
 
-using std::unique_ptr;
-
 namespace brave_etld {
 
 struct PublicSuffixRuleSetMatchResult {
diff --git a/protocol.cc b/protocol.cc
index 0141c32..4281dc7 100644
--- a/protocol.cc
+++ b/protocol.cc
@@ -42,7 +42,7 @@ bool isBlockableProtocol(const char *url, int urlLen) {
 
   const char *curChar = url;
   int totalCharsRead = 0;
-  int numCharsReadInState;
+  int numCharsReadInState = 0;
   char lowerChar;
   ProtocolParseState parseState = ProtocolParseStateStart;
 
diff --git a/test/etld_serialization_test.cc b/test/etld_serialization_test.cc
index 520d27e..7750905 100644
--- a/test/etld_serialization_test.cc
+++ b/test/etld_serialization_test.cc
@@ -73,46 +73,6 @@ TEST(eTLDSerializationMatcher, basic) {
   CHECK(testSerializeMatcher("!one.com\n*.two.com\nthree.com"));
 }
 
-bool testDeserializationCorrectness(const SerializedBuffer &rule_text,
-    int num_rules, int num_exception_rules) {
-  Matcher matcher = matcher_from_serialization(rule_text);
-  int num_matcher_rules = static_cast<int>(matcher.NumRules());
-  if (num_matcher_rules != num_rules) {
-    std::cout << "Expected " << num_rules << " rules from buffer, but received "
-              << num_matcher_rules << " rules." << std::endl;
-    return false;
-  }
-
-  int num_matcher_except_rules = static_cast<int>(matcher.NumExceptionRules());
-  if (num_matcher_except_rules != num_exception_rules) {
-    std::cout << "Expected " << num_rules << " exception rules from buffer, "
-              << "but received " <<  num_exception_rules << " rules."
-              << std::endl;
-    return false;
-  }
-
-  return true;
-}
-
-// TEST(eTLDDeserializationTests, basic) {
-//   CHECK(testDeserializationCorrectness(
-//     "47:42:29:ff||not-matching-anything.com8:fftrees^0:", 2, 0));
-// }
-
-bool testSerializationCorrectness(const string &rule_text,
-    const SerializedBuffer &serialized) {
-  Matcher matcher(rule_text);
-  SerializationResult result = matcher.Serialize();
-  return result.buffer.compare(serialized) == 0;
-}
-
-// TEST(eTLDSerializationTests, basic) {
-//   const string rules = "||s3.amazonaws.com^$third-party\n"
-//                        "||not-matching-anything.com\n"
-//                        "trees^";
-//   CHECK(testSerializationCorrectness(rules, ));
-// }
-
 bool testMatcherSerializationTransitivity(const string &public_suffix_rules) {
   Matcher orig(public_suffix_rules);
   SerializationResult res = orig.Serialize();
@@ -135,7 +95,7 @@ bool testAdBlockClientSerializationTransitivity(const string &filter_rules,
   AdBlockClient client;
   client.parse(filter_rules.c_str());
   client.parsePublicSuffixRules(public_suffix_rules.c_str());
-  
+
   int size;
   char* buffer = client.serialize(&size);
 
@@ -167,4 +127,4 @@ TEST(eTLDSerializationTransitivity, basic) {
   CHECK(testMatcherSerializationTransitivity(public_suffix_rules));
   CHECK(testAdBlockClientSerializationTransitivity(
     filer_rules, public_suffix_rules));
-}
\ No newline at end of file
+}
diff --git a/test/etld_test.cc b/test/etld_test.cc
index 0ec0bbb..ee57df1 100644
--- a/test/etld_test.cc
+++ b/test/etld_test.cc
@@ -543,4 +543,4 @@ TEST(eTLDPublicSuffixRuleApplyFileTests, basic) {
       elm.input,
       elm.expected));
   }
-}
\ No newline at end of file
+}
diff --git a/test/parser_test.cc b/test/parser_test.cc
index 631548c..06f8302 100644
--- a/test/parser_test.cc
+++ b/test/parser_test.cc
@@ -52,7 +52,8 @@ bool testFilter(const char *rawFilter, FilterType expectedFilterType,
   string lastChecked;
   std::for_each(blocked.begin(), blocked.end(),
       [&filter, &ret, &lastChecked, &expectedFilterOption](string const &s) {
-    ret = ret && filter.matches(s.c_str(), (FilterOption)(expectedFilterOption & FOResourcesOnly));
+    ret = ret && filter.matches(s.c_str(),
+      (FilterOption)(expectedFilterOption & FOResourcesOnly));
     lastChecked = s;
   });
   if (!ret) {
@@ -62,7 +63,8 @@ bool testFilter(const char *rawFilter, FilterType expectedFilterType,
 
   std::for_each(notBlocked.begin(), notBlocked.end(),
       [&filter, &ret, &lastChecked, &expectedFilterOption](string const &s) {
-    ret = ret && !filter.matches(s.c_str(), (FilterOption)(expectedFilterOption & FOResourcesOnly));
+    ret = ret && !filter.matches(s.c_str(),
+      (FilterOption)(expectedFilterOption & FOResourcesOnly));
     lastChecked = s;
   });
   if (!ret) {

From adb1dafb5009ac4da46b5f5fcf9b12aca10cc58f Mon Sep 17 00:00:00 2001
From: "Brian R. Bondy" <netzen@gmail.com>
Date: Fri, 22 Feb 2019 23:30:44 -0500
Subject: [PATCH 04/13] Use psl in perf application

---
 perf.cc          |  7 +++++++
 perf/binding.gyp | 13 +++++++++++++
 2 files changed, 20 insertions(+)

diff --git a/perf.cc b/perf.cc
index 10602bd..8d69f88 100644
--- a/perf.cc
+++ b/perf.cc
@@ -81,6 +81,10 @@ int main(int argc, char**argv) {
   std::string && disconnectSimpleMalwareTxt =
     getFileContents("./test/data/disconnect-simple-malware.txt");
 
+  std::ifstream ifs("./test/data/public_suffix_list.dat");
+  const string public_suffix_rules((std::istreambuf_iterator<char>(ifs)),
+                                   (std::istreambuf_iterator<char>()));
+
   cout << endl
     << "-------------\n"
     << "  AD BLOCK   \n"
@@ -92,6 +96,7 @@ int main(int argc, char**argv) {
   adBlockClient.parse(easyPrivacyTxt.c_str());
   adBlockClient.parse(ublockUnblockTxt.c_str());
   adBlockClient.parse(braveUnblockTxt.c_str());
+  adBlockClient.parsePublicSuffixRules(public_suffix_rules.c_str());
   doSiteList(&adBlockClient, true);
 
   cout << endl
@@ -103,6 +108,7 @@ int main(int argc, char**argv) {
   AdBlockClient safeBrowsingClient;
   safeBrowsingClient.parse(spam404MainBlacklistTxt.c_str());
   safeBrowsingClient.parse(disconnectSimpleMalwareTxt.c_str());
+  safeBrowsingClient.parsePublicSuffixRules(public_suffix_rules.c_str());
   doSiteList(&safeBrowsingClient, true);
 
   cout << endl
@@ -118,6 +124,7 @@ int main(int argc, char**argv) {
   allClient.parse(braveUnblockTxt.c_str());
   allClient.parse(spam404MainBlacklistTxt.c_str());
   allClient.parse(disconnectSimpleMalwareTxt.c_str());
+  allClient.parsePublicSuffixRules(public_suffix_rules.c_str());
   doSiteList(&allClient, false);
   allClient.badFingerprintsHashSet->generateHeader("bad_fingerprints.h");
 
diff --git a/perf/binding.gyp b/perf/binding.gyp
index 7d4c20d..c5aa478 100644
--- a/perf/binding.gyp
+++ b/perf/binding.gyp
@@ -12,6 +12,19 @@
       "../context_domain.h",
       "../cosmetic_filter.cc",
       "../cosmetic_filter.h",
+      "../etld/domain.cc",
+      "../etld/domain.h",
+      "../etld/matcher.cc",
+      "../etld/matcher.h",
+      "../etld/parser.cc",
+      "../etld/parser.h",
+      "../etld/public_suffix_rule_set.cc",
+      "../etld/public_suffix_rule_set.h",
+      "../etld/public_suffix_rule.cc",
+      "../etld/public_suffix_rule.h",
+      "../etld/serialization.cc",
+      "../etld/serialization.h",
+      "../etld/types.h",
       "../filter.cc",
       "../filter.h",
       "../filter_list.cc",

From 863d1be5249f85448442be74efc7cbd3a780c7c7 Mon Sep 17 00:00:00 2001
From: Peter Snyder <snyderp@gmail.com>
Date: Sat, 23 Feb 2019 19:05:56 -0800
Subject: [PATCH 05/13] refactor to avoid unneeded allocations

---
 binding.gyp                                   | 12 ++--
 brave/BUILD.gn                                | 12 ++--
 etld/domain.cc                                | 16 ++---
 etld/domain.h                                 |  2 +-
 etld/{ => internal}/parser.cc                 | 52 +++++++--------
 etld/{ => internal}/parser.h                  | 26 ++++----
 etld/{ => internal}/public_suffix_rule.cc     | 56 ++++++++--------
 etld/{ => internal}/public_suffix_rule.h      | 11 ++--
 etld/{ => internal}/public_suffix_rule_set.cc | 43 ++++++------
 etld/{ => internal}/public_suffix_rule_set.h  | 14 ++--
 etld/matcher.cc                               | 44 +++++++------
 etld/matcher.h                                | 20 +++---
 etld/serialization.h                          | 10 +--
 etld/types.h                                  | 10 +--
 muon/BUILD.gn                                 | 12 ++--
 perf/binding.gyp                              | 12 ++--
 test/binding.gyp                              | 28 ++++----
 test/etld_blocking_test.cc                    |  8 ---
 test/etld_serialization_test.cc               | 14 ++--
 test/etld_test.cc                             | 66 +++++++++++++------
 20 files changed, 241 insertions(+), 227 deletions(-)
 rename etld/{ => internal}/parser.cc (61%)
 rename etld/{ => internal}/parser.h (72%)
 rename etld/{ => internal}/public_suffix_rule.cc (87%)
 rename etld/{ => internal}/public_suffix_rule.h (86%)
 rename etld/{ => internal}/public_suffix_rule_set.cc (80%)
 rename etld/{ => internal}/public_suffix_rule_set.h (76%)

diff --git a/binding.gyp b/binding.gyp
index a260a88..283b48c 100644
--- a/binding.gyp
+++ b/binding.gyp
@@ -23,12 +23,12 @@
       "etld/domain.h",
       "etld/matcher.cc",
       "etld/matcher.h",
-      "etld/parser.cc",
-      "etld/parser.h",
-      "etld/public_suffix_rule_set.cc",
-      "etld/public_suffix_rule_set.h",
-      "etld/public_suffix_rule.cc",
-      "etld/public_suffix_rule.h",
+      "etld/internal/parser.cc",
+      "etld/internal/parser.h",
+      "etld/internal/public_suffix_rule_set.cc",
+      "etld/internal/public_suffix_rule_set.h",
+      "etld/internal/public_suffix_rule.cc",
+      "etld/internal/public_suffix_rule.h",
       "etld/serialization.cc",
       "etld/serialization.h",
       "etld/types.h",
diff --git a/brave/BUILD.gn b/brave/BUILD.gn
index cd219ba..9c95ffd 100644
--- a/brave/BUILD.gn
+++ b/brave/BUILD.gn
@@ -30,12 +30,12 @@ source_set("ad-block") {
     "../etld/domain.h",
     "../etld/matcher.cc",
     "../etld/matcher.h",
-    "../etld/parser.cc",
-    "../etld/parser.h",
-    "../etld/public_suffix_rule.cc",
-    "../etld/public_suffix_rule.h",
-    "../etld/public_suffix_rule_set.cc",
-    "../etld/public_suffix_rule_set.h",
+    "../etld/internal/parser.cc",
+    "../etld/internal/parser.h",
+    "../etld/internal/public_suffix_rule.cc",
+    "../etld/internal/public_suffix_rule.h",
+    "../etld/internal/public_suffix_rule_set.cc",
+    "../etld/internal/public_suffix_rule_set.h",
     "../etld/serialization.cc",
     "../etld/serialization.h",
     "../etld/types.h",
diff --git a/etld/domain.cc b/etld/domain.cc
index 827f24c..8e52d94 100644
--- a/etld/domain.cc
+++ b/etld/domain.cc
@@ -9,9 +9,11 @@
 
 namespace brave_etld {
 
-Domain::Domain(const Domain &domain) {
-  labels_ = domain.labels_;
-}
+Domain::Domain(const Domain &domain) :
+  labels_(domain.labels_) {}
+
+Domain::Domain(const std::vector<Label> &labels) :
+  labels_(labels) {}
 
 Domain::Domain(const std::string &string) {
   std::size_t current, previous = 0;
@@ -32,12 +34,8 @@ Domain::Domain(const std::string &string) {
   }
 }
 
-Domain::Domain(const std::vector<Label> &labels) {
-  labels_ = labels;
-}
-
 bool Domain::Equals(const Domain &domain) {
-  size_t local_length = Length();
+  const size_t local_length = Length();
   if (local_length != domain.Length()) {
     return false;
   }
@@ -53,7 +51,7 @@ bool Domain::Equals(const Domain &domain) {
 
 std::string Domain::ToString() const {
   std::stringstream as_string;
-  auto num_labels = labels_.size();
+  const size_t num_labels = labels_.size();
   size_t i = 0;
   for (auto &str : labels_) {
     as_string << str;
diff --git a/etld/domain.h b/etld/domain.h
index a0be563..e060c29 100644
--- a/etld/domain.h
+++ b/etld/domain.h
@@ -24,7 +24,7 @@ class Domain {
     return labels_.size();
   }
 
-  Label Get(std::size_t idx) const {
+  const Label& Get(std::size_t idx) const {
     return labels_[idx];
   }
 
diff --git a/etld/parser.cc b/etld/internal/parser.cc
similarity index 61%
rename from etld/parser.cc
rename to etld/internal/parser.cc
index 3f421f8..c97a691 100644
--- a/etld/parser.cc
+++ b/etld/internal/parser.cc
@@ -7,31 +7,32 @@
 #include <sstream>
 #include <fstream>
 #include <vector>
-#include "etld/parser.h"
-#include "etld/public_suffix_rule.h"
+#include "etld/internal/parser.h"
+#include "etld/internal/public_suffix_rule.h"
 #include "etld/types.h"
 
 namespace brave_etld {
+namespace internal {
 
 PublicSuffixParseResult::PublicSuffixParseResult() {}
 
 PublicSuffixParseResult::PublicSuffixParseResult(
-    const PublicSuffixParseResult &results) {
-  num_whitespace_lines_ = results.num_whitespace_lines_;
-  num_comment_lines_ = results.num_comment_lines_;
-  num_invalid_rules_ = results.num_invalid_rules_;
-  rules_ = results.rules_;
-}
+    const PublicSuffixParseResult &results) :
+  num_whitespace_lines_(results.num_whitespace_lines_),
+  num_comment_lines_(results.num_comment_lines_),
+  num_invalid_rules_(results.num_invalid_rules_),
+  rules_(results.rules_) {}
 
-std::vector<PublicSuffixRule> PublicSuffixParseResult::Rules() const {
+const std::vector<PublicSuffixRule>& PublicSuffixParseResult::Rules() const {
   return rules_;
 }
 
-void PublicSuffixParseResult::AddParseResult(
+void PublicSuffixParseResult::ConsumeParseResult(
     const PublicSuffixTextLineParseResult &result) {
   switch (result.type) {
     case PublicSuffixTextLineTypeRule:
-      rules_.push_back(result.rule);
+      rules_.push_back(*(result.rule));
+      delete result.rule;
       break;
 
     case PublicSuffixTextLineTypeWhitespace:
@@ -54,10 +55,8 @@ void PublicSuffixParseResult::AddParseResult(
 PublicSuffixParseResult parse_rule_file(std::ifstream &rule_file) {
   std::string line;
   PublicSuffixParseResult results;
-  PublicSuffixTextLineParseResult line_result;
   while (std::getline(rule_file, line)) {
-    line_result = parse_rule_line(line);
-    results.AddParseResult(line_result);
+    results.ConsumeParseResult(parse_rule_line(line));
   }
 
   return results;
@@ -67,39 +66,34 @@ PublicSuffixParseResult parse_rule_text(const std::string &text) {
   std::istringstream stream(text);
   std::string line;
   PublicSuffixParseResult results;
-  PublicSuffixTextLineParseResult line_result;
   while (std::getline(stream, line)) {
-    line_result = parse_rule_line(line);
-    results.AddParseResult(line_result);
+    results.ConsumeParseResult(parse_rule_line(line));
   }
 
   return results;
 }
 
 PublicSuffixTextLineParseResult parse_rule_line(const std::string &line) {
-  PublicSuffixTextLineParseResult result;
-
   // Check to see if this is a comment line.  If so, process no further.
   if (line.find("//") == 0) {
-    result.type = PublicSuffixTextLineTypeComment;
-    return result;
+    return PublicSuffixTextLineParseResult(PublicSuffixTextLineTypeComment);
   }
 
-  std::size_t first_non_white_space_char = line.find_first_not_of(" ");
+  const size_t first_non_white_space_char = line.find_first_not_of(" ");
   // Next, check to see if the line is only whitespace.
   if (first_non_white_space_char == std::string::npos) {
-    result.type = PublicSuffixTextLineTypeWhitespace;
-    return result;
+    return PublicSuffixTextLineParseResult(PublicSuffixTextLineTypeWhitespace);
   }
 
   try {
-    result.rule = PublicSuffixRule(line);
-    result.type = PublicSuffixTextLineTypeRule;
+    return PublicSuffixTextLineParseResult(
+      PublicSuffixTextLineTypeRule,
+      new PublicSuffixRule(line)
+    );
   } catch (PublicSuffixRuleInputException error) {
-    result.type = PublicSuffixTextLineTypeInvalidRule;
+    return PublicSuffixTextLineParseResult(PublicSuffixTextLineTypeInvalidRule);
   }
-
-  return result;
 }
 
+}  // namespace internal
 }  // namespace brave_etld
diff --git a/etld/parser.h b/etld/internal/parser.h
similarity index 72%
rename from etld/parser.h
rename to etld/internal/parser.h
index e4032c4..9aab96d 100644
--- a/etld/parser.h
+++ b/etld/internal/parser.h
@@ -3,16 +3,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef ETLD_PARSER_H_
-#define ETLD_PARSER_H_
+#ifndef ETLD_INTERNAL_PARSER_H_
+#define ETLD_INTERNAL_PARSER_H_
 
 #include <string>
 #include <fstream>
 #include <vector>
-#include "etld/public_suffix_rule.h"
+#include "etld/internal/public_suffix_rule.h"
 #include "etld/types.h"
 
 namespace brave_etld {
+namespace internal {
 
 enum PublicSuffixTextLineType {
   PublicSuffixTextLineTypeNone = 0,
@@ -23,11 +24,13 @@ enum PublicSuffixTextLineType {
 };
 
 struct PublicSuffixTextLineParseResult {
-  PublicSuffixTextLineParseResult() {
-    type = PublicSuffixTextLineTypeNone;
-  }
-  PublicSuffixTextLineType type;
-  PublicSuffixRule rule;
+  PublicSuffixTextLineParseResult(
+      PublicSuffixTextLineType type = PublicSuffixTextLineTypeNone,
+      const PublicSuffixRule * rule = nullptr) : 
+    type(type),
+    rule(rule) {}
+  const PublicSuffixTextLineType type;
+  const PublicSuffixRule* rule;
 };
 
 class PublicSuffixParseResult {
@@ -35,8 +38,8 @@ class PublicSuffixParseResult {
   PublicSuffixParseResult();
   PublicSuffixParseResult(const PublicSuffixParseResult &results);
 
-  std::vector<PublicSuffixRule> Rules() const;
-  void AddParseResult(const PublicSuffixTextLineParseResult &result);
+  const std::vector<PublicSuffixRule>& Rules() const;
+  void ConsumeParseResult(const PublicSuffixTextLineParseResult &result);
 
   int NumWhitespaceLines() const {
     return num_whitespace_lines_;
@@ -63,6 +66,7 @@ PublicSuffixParseResult parse_rule_file(std::ifstream &rule_file);
 PublicSuffixParseResult parse_rule_text(const std::string &rule_text);
 PublicSuffixTextLineParseResult parse_rule_line(const std::string &line);
 
+}  // namespace internal
 }  // namespace brave_etld
 
-#endif  // ETLD_PARSER_H_
+#endif  // ETLD_INTERNAL_PARSER_H_
diff --git a/etld/public_suffix_rule.cc b/etld/internal/public_suffix_rule.cc
similarity index 87%
rename from etld/public_suffix_rule.cc
rename to etld/internal/public_suffix_rule.cc
index 94932eb..a7a7c2b 100644
--- a/etld/public_suffix_rule.cc
+++ b/etld/internal/public_suffix_rule.cc
@@ -9,11 +9,14 @@
 #include <cstdio>
 #include <iostream>
 #include "etld/domain.h"
-#include "etld/public_suffix_rule.h"
+#include "etld/internal/public_suffix_rule.h"
 #include "etld/types.h"
 #include "etld/serialization.h"
 
 namespace brave_etld {
+namespace internal {
+
+const PublicSuffixRule * PublicSuffixRule::root_rule = new PublicSuffixRule("*");
 
 std::vector<Label> parse_labels(const std::string &label_text) {
   std::vector<Label> labels;
@@ -56,17 +59,12 @@ std::string trim_to_whitespace(std::string const& str) {
   return str.substr(0, first_scan);
 }
 
-PublicSuffixRule::PublicSuffixRule() {
-  labels_ = std::vector<Label>();
-  is_exception_ = false;
-  is_wildcard_ = false;
-}
+PublicSuffixRule::PublicSuffixRule() {}
 
-PublicSuffixRule::PublicSuffixRule(const PublicSuffixRule &rule) {
-  labels_ = rule.Labels();
-  is_exception_ = rule.IsException();
-  is_wildcard_ = rule.IsWildcard();
-}
+PublicSuffixRule::PublicSuffixRule(const PublicSuffixRule &rule) :
+  labels_(rule.Labels()),
+  is_exception_(rule.IsException()),
+  is_wildcard_(rule.IsWildcard()) {}
 
 PublicSuffixRule::PublicSuffixRule(const std::string &rule_text) {
   std::string trimmed_rule_text(trim_to_whitespace(rule_text));
@@ -107,7 +105,6 @@ PublicSuffixRule::PublicSuffixRule(const std::vector<Label> &labels,
 }
 
 SerializationResult PublicSuffixRule::Serialize() const {
-  SerializationResult info;
   const std::string domain_string = DomainString();
   const size_t body_len = domain_string.size() + 2;
   const std::string header_str = std::to_string(body_len);
@@ -125,15 +122,16 @@ SerializationResult PublicSuffixRule::Serialize() const {
     is_wildcard_ ? 't' : 'f',
     domain_string.c_str());
 
-  info.body_start = body_start;
-  info.body_len = body_len;
-  info.buffer = buffer;
-  return info;
+  return {
+    buffer,
+    body_start,
+    body_len
+  };
 }
 
 bool PublicSuffixRule::Equals(const PublicSuffixRule &rule) const {
   return (
-    labels_ == rule.Labels() &&
+    labels_ == rule.labels_ &&
     is_exception_ == rule.IsException() &&
     is_wildcard_ == rule.IsWildcard());
 }
@@ -143,8 +141,8 @@ bool PublicSuffixRule::Equals(const PublicSuffixRule &rule) const {
 bool PublicSuffixRule::Matches(const Domain &domain) const {
   // When the domain and rule are split into corresponding labels, that the
   // domain contains as many or more labels than the rule.
-  auto num_rule_labels = labels_.size();
-  auto num_domain_labels = domain.Length();
+  const size_t num_rule_labels = labels_.size();
+  const size_t num_domain_labels = domain.Length();
   if (num_rule_labels > num_domain_labels) {
     return false;
   }
@@ -153,8 +151,8 @@ bool PublicSuffixRule::Matches(const Domain &domain) const {
   // continuing for all labels in the rule, one finds that for every pair,
   // either they are identical, or that the label from the rule is "*".
   for (size_t i = 0; i < num_rule_labels; i += 1) {
-    Label rule_label = labels_[num_rule_labels - i - 1];
-    Label domain_label = domain.Get(num_domain_labels - i - 1);
+    const Label& rule_label = labels_[num_rule_labels - i - 1];
+    const Label& domain_label = domain.Get(num_domain_labels - i - 1);
 
     if (rule_label == "*") {
       continue;
@@ -169,8 +167,6 @@ bool PublicSuffixRule::Matches(const Domain &domain) const {
 }
 
 DomainInfo PublicSuffixRule::Apply(const Domain &domain) const {
-  DomainInfo domain_info;
-
   auto domain_len = domain.Length();
   auto rule_len = Length();
   if (IsException()) {
@@ -215,10 +211,11 @@ DomainInfo PublicSuffixRule::Apply(const Domain &domain) const {
     }
   }
 
-  domain_info.tld = tld_seg.str();
-  domain_info.domain = domain_seg.str();
-  domain_info.subdomain = sub_domain_seg.str();
-  return domain_info;
+  return {
+    tld_seg.str(),
+    domain_seg.str(),
+    sub_domain_seg.str()
+  };
 }
 
 std::string PublicSuffixRule::DomainString() const {
@@ -236,7 +233,7 @@ std::string PublicSuffixRule::DomainString() const {
   return as_string.str();
 }
 
-std::vector<Label> PublicSuffixRule::Labels() const {
+const std::vector<Label>& PublicSuffixRule::Labels() const {
   return labels_;
 }
 
@@ -258,8 +255,9 @@ PublicSuffixRule rule_from_serialization(const SerializedBuffer &buffer) {
   bool is_exception = body_str[0] == 't';
   bool is_wildcard = body_str[1] == 't';
   const std::string label_str(body_str, 2, info.body_len - 2);
-  std::vector<Label> labels = parse_labels(label_str);
+  const std::vector<Label> labels = parse_labels(label_str);
   return PublicSuffixRule(labels, is_exception, is_wildcard);
 }
 
+}  // namespace internal
 }  // namespace brave_etld
diff --git a/etld/public_suffix_rule.h b/etld/internal/public_suffix_rule.h
similarity index 86%
rename from etld/public_suffix_rule.h
rename to etld/internal/public_suffix_rule.h
index fc259d9..2aaf7d6 100644
--- a/etld/public_suffix_rule.h
+++ b/etld/internal/public_suffix_rule.h
@@ -3,8 +3,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef ETLD_PUBLIC_SUFFIX_RULE_H_
-#define ETLD_PUBLIC_SUFFIX_RULE_H_
+#ifndef ETLD_INTERNAL_PUBLIC_SUFFIX_RULE_H_
+#define ETLD_INTERNAL_PUBLIC_SUFFIX_RULE_H_
 
 #include <string>
 #include <vector>
@@ -13,6 +13,7 @@
 #include "etld/serialization.h"
 
 namespace brave_etld {
+namespace internal {
 
 class PublicSuffixRuleInputException : public std::exception {
  public:
@@ -31,6 +32,7 @@ class PublicSuffixRuleInputException : public std::exception {
 
 class PublicSuffixRule {
  public:
+  static const PublicSuffixRule * root_rule;
   PublicSuffixRule();
   PublicSuffixRule(const PublicSuffixRule &rule);
   explicit PublicSuffixRule(const std::string &rule_text);
@@ -47,7 +49,7 @@ class PublicSuffixRule {
   std::string ToString() const;
   std::string DomainString() const;
 
-  std::vector<Label> Labels() const;
+  const std::vector<Label>& Labels() const;
   size_t Length() const;
 
   bool IsException() const {
@@ -66,6 +68,7 @@ class PublicSuffixRule {
 PublicSuffixRule rule_from_serialization(const SerializedBuffer &buffer);
 std::vector<Label> parse_labels(const std::string &label_text);
 
+}  // namespace internal
 }  // namespace brave_etld
 
-#endif  // ETLD_PUBLIC_SUFFIX_RULE_H_
+#endif  // ETLD_INTERNAL_PUBLIC_SUFFIX_RULE_H_
diff --git a/etld/public_suffix_rule_set.cc b/etld/internal/public_suffix_rule_set.cc
similarity index 80%
rename from etld/public_suffix_rule_set.cc
rename to etld/internal/public_suffix_rule_set.cc
index 97fd2c5..a6cfea2 100644
--- a/etld/public_suffix_rule_set.cc
+++ b/etld/internal/public_suffix_rule_set.cc
@@ -7,24 +7,25 @@
 #include <sstream>
 #include <vector>
 #include <iostream>
-#include "etld/public_suffix_rule.h"
-#include "etld/public_suffix_rule_set.h"
+#include "etld/internal/public_suffix_rule.h"
+#include "etld/internal/public_suffix_rule_set.h"
 #include "etld/domain.h"
 #include "etld/types.h"
 #include "etld/serialization.h"
 
+using brave_etld::internal::PublicSuffixRuleSetMatchResult;
+
 namespace brave_etld {
+namespace internal {
 
 PublicSuffixRuleSet::PublicSuffixRuleSet() {}
 
-PublicSuffixRuleSet::PublicSuffixRuleSet(const PublicSuffixRuleSet &rule_set) {
-  rules_ = rule_set.Rules();
-}
+PublicSuffixRuleSet::PublicSuffixRuleSet(const PublicSuffixRuleSet &rule_set) :
+  rules_(rule_set.Rules()) {}
 
 PublicSuffixRuleSet::PublicSuffixRuleSet(
-    const std::vector<PublicSuffixRule> &rules) {
-  rules_ = rules;
-}
+    const std::vector<PublicSuffixRule> &rules) : 
+  rules_(rules) {}
 
 bool PublicSuffixRuleSet::Equal(const PublicSuffixRuleSet &rule_set) const {
   if (rules_.size() != rule_set.rules_.size()) {
@@ -69,45 +70,40 @@ SerializationResult PublicSuffixRuleSet::Serialize() const {
     header_str.c_str(),
     buffer_body.c_str());
 
-  SerializationResult info;
-  info.body_start = body_start;
-  info.body_len = body_len;
-  info.buffer = buffer;
-  return info;
+  return {
+    buffer,
+    body_start,
+    body_len
+  };
 }
 
 PublicSuffixRuleSetMatchResult PublicSuffixRuleSet::Match(
     const Domain &domain) const {
   int longest_length = -1;
   int found_length;
-  PublicSuffixRule longest_rule;
+  const PublicSuffixRule * longest_rule;
   for (auto &elm : rules_) {
     if (elm.Matches(domain)) {
       found_length = elm.Labels().size();
       if (found_length > longest_length) {
-        longest_rule = elm;
+        longest_rule = &elm;
         longest_length = found_length;
       }
     }
   }
 
-  PublicSuffixRuleSetMatchResult result;
-
   if (longest_length == -1) {
-    result.found_match = false;
-    return result;
+    return {false, nullptr};
   }
 
-  result.found_match = true;
-  result.rule = longest_rule;
-  return result;
+  return {true, longest_rule};
 }
 
 void PublicSuffixRuleSet::AddRule(const PublicSuffixRule &rule) {
   rules_.push_back(rule);
 }
 
-std::vector<PublicSuffixRule> PublicSuffixRuleSet::Rules() const {
+const std::vector<PublicSuffixRule>& PublicSuffixRuleSet::Rules() const {
   return rules_;
 }
 
@@ -120,4 +116,5 @@ PublicSuffixRuleSet rule_set_from_serialization(
   return PublicSuffixRuleSet(rules);
 }
 
+}  // namespace internal
 }  // namespace brave_etld
diff --git a/etld/public_suffix_rule_set.h b/etld/internal/public_suffix_rule_set.h
similarity index 76%
rename from etld/public_suffix_rule_set.h
rename to etld/internal/public_suffix_rule_set.h
index 95e8a20..3a79078 100644
--- a/etld/public_suffix_rule_set.h
+++ b/etld/internal/public_suffix_rule_set.h
@@ -3,21 +3,22 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef ETLD_PUBLIC_SUFFIX_RULE_SET_H_
-#define ETLD_PUBLIC_SUFFIX_RULE_SET_H_
+#ifndef ETLD_INTERNAL_PUBLIC_SUFFIX_RULE_SET_H_
+#define ETLD_INTERNAL_PUBLIC_SUFFIX_RULE_SET_H_
 
 #include <string>
 #include <vector>
-#include "etld/public_suffix_rule.h"
+#include "etld/internal/public_suffix_rule.h"
 #include "etld/domain.h"
 #include "etld/types.h"
 #include "etld/serialization.h"
 
 namespace brave_etld {
+namespace internal {
 
 struct PublicSuffixRuleSetMatchResult {
   bool found_match;
-  PublicSuffixRule rule;
+  const PublicSuffixRule * rule;
 };
 
 class PublicSuffixRuleSet {
@@ -30,7 +31,7 @@ class PublicSuffixRuleSet {
   bool Equal(const PublicSuffixRuleSet &rule_set) const;
   PublicSuffixRuleSetMatchResult Match(const Domain &domain) const;
   void AddRule(const PublicSuffixRule &rule);
-  std::vector<PublicSuffixRule> Rules() const;
+  const std::vector<PublicSuffixRule>& Rules() const;
 
  private:
   std::vector<PublicSuffixRule> rules_;
@@ -38,6 +39,7 @@ class PublicSuffixRuleSet {
 
 PublicSuffixRuleSet rule_set_from_serialization(const SerializedBuffer &buffer);
 
+}  // namespace internal
 }  // namespace brave_etld
 
-#endif  // ETLD_PUBLIC_SUFFIX_RULE_SET_H_
+#endif  // ETLD_INTERNAL_PUBLIC_SUFFIX_RULE_SET_H_
diff --git a/etld/matcher.cc b/etld/matcher.cc
index fde03ca..754135a 100644
--- a/etld/matcher.cc
+++ b/etld/matcher.cc
@@ -6,19 +6,27 @@
 #include <fstream>
 #include <sstream>
 #include "etld/types.h"
-#include "etld/parser.h"
-#include "etld/public_suffix_rule.h"
+#include "etld/internal/parser.h"
+#include "etld/internal/public_suffix_rule.h"
 #include "etld/matcher.h"
 #include "etld/serialization.h"
 
+using brave_etld::internal::PublicSuffixParseResult;
+using brave_etld::internal::PublicSuffixRuleSetMatchResult;
+
 namespace brave_etld {
 
+DomainInfo build_domain_info_(const internal::PublicSuffixRule * rule,
+  const Domain &domain) {
+  return rule->Apply(domain);
+}
+
 Matcher::Matcher(std::ifstream &rule_file) {
-  ConsumeParseResult(parse_rule_file(rule_file));
+  ConsumeParseResult(internal::parse_rule_file(rule_file));
 }
 
 Matcher::Matcher(const std::string &rule_text) {
-  ConsumeParseResult(parse_rule_text(rule_text));
+  ConsumeParseResult(internal::parse_rule_text(rule_text));
 }
 
 Matcher::Matcher(const PublicSuffixParseResult &rules) {
@@ -29,8 +37,8 @@ Matcher::Matcher(const Matcher &matcher) :
   rules_(matcher.rules_),
   exception_rules_(matcher.exception_rules_) {}
 
-Matcher::Matcher(const PublicSuffixRuleSet &rules,
-    const PublicSuffixRuleSet &exception_rules) :
+Matcher::Matcher(const internal::PublicSuffixRuleSet &rules,
+    const internal::PublicSuffixRuleSet &exception_rules) :
   rules_(rules),
   exception_rules_(exception_rules) {}
 
@@ -54,11 +62,11 @@ SerializationResult Matcher::Serialize() const {
     header_str.c_str(),
     buffer_body.c_str());
 
-  SerializationResult info;
-  info.body_start = body_start;
-  info.body_len = body_len;
-  info.buffer = buffer;
-  return info;
+  return {
+    buffer,
+    body_start,
+    body_len
+  };
 }
 
 bool Matcher::Equal(const Matcher &matcher) const {
@@ -71,21 +79,17 @@ bool Matcher::Equal(const Matcher &matcher) const {
 DomainInfo Matcher::Match(const Domain &domain) const {
   PublicSuffixRuleSetMatchResult except_match = exception_rules_.Match(domain);
   if (except_match.found_match) {
-    return BuildDomainInfo(except_match.rule, domain);
+    return build_domain_info_(except_match.rule, domain);
   }
 
   PublicSuffixRuleSetMatchResult rule_match = rules_.Match(domain);
   if (rule_match.found_match) {
-    return BuildDomainInfo(rule_match.rule, domain);
+    return build_domain_info_(rule_match.rule, domain);
   }
 
-  return BuildDomainInfo(PublicSuffixRule("*"), domain);
+  return build_domain_info_(internal::PublicSuffixRule::root_rule, domain);
 }
 
-DomainInfo Matcher::BuildDomainInfo(const PublicSuffixRule &rule,
-    const Domain &domain) const {
-  return rule.Apply(domain);
-}
 
 void Matcher::ConsumeParseResult(const PublicSuffixParseResult &result) {
   for (auto &elm : result.Rules()) {
@@ -100,8 +104,8 @@ void Matcher::ConsumeParseResult(const PublicSuffixParseResult &result) {
 Matcher matcher_from_serialization(const SerializedBuffer &buffer) {
   SerializedChildBuffers child_buffers = deserialize_buffer(buffer);
   return {
-    rule_set_from_serialization(child_buffers[0]),
-    rule_set_from_serialization(child_buffers[1])
+    internal::rule_set_from_serialization(child_buffers[0]),
+    internal::rule_set_from_serialization(child_buffers[1])
   };
 }
 
diff --git a/etld/matcher.h b/etld/matcher.h
index 6a9b59d..77abbbf 100644
--- a/etld/matcher.h
+++ b/etld/matcher.h
@@ -11,9 +11,9 @@
 #include <vector>
 #include "etld/domain.h"
 #include "etld/types.h"
-#include "etld/parser.h"
-#include "etld/public_suffix_rule.h"
-#include "etld/public_suffix_rule_set.h"
+#include "etld/internal/parser.h"
+#include "etld/internal/public_suffix_rule.h"
+#include "etld/internal/public_suffix_rule_set.h"
 #include "etld/serialization.h"
 
 namespace brave_etld {
@@ -24,14 +24,14 @@ class Matcher {
   Matcher(const Matcher &matcher);
   explicit Matcher(std::ifstream &rule_file);
   explicit Matcher(const std::string &rule_text);
-  explicit Matcher(const PublicSuffixParseResult &rules);
-  Matcher(const PublicSuffixRuleSet &rules,
-    const PublicSuffixRuleSet &exception_rules);
+  explicit Matcher(const internal::PublicSuffixParseResult &rules);
+  Matcher(const internal::PublicSuffixRuleSet &rules,
+    const internal::PublicSuffixRuleSet &exception_rules);
 
   SerializationResult Serialize() const;
 
   bool Equal(const Matcher &matcher) const;
-  void ConsumeParseResult(const PublicSuffixParseResult &result);
+  void ConsumeParseResult(const internal::PublicSuffixParseResult &result);
   DomainInfo Match(const Domain &domain) const;
 
   size_t NumRules() const {
@@ -43,10 +43,8 @@ class Matcher {
   }
 
  private:
-  DomainInfo BuildDomainInfo(const PublicSuffixRule &rule,
-    const Domain &domain) const;
-  PublicSuffixRuleSet rules_;
-  PublicSuffixRuleSet exception_rules_;
+  internal::PublicSuffixRuleSet rules_;
+  internal::PublicSuffixRuleSet exception_rules_;
 };
 
 Matcher matcher_from_serialization(const SerializedBuffer &buffer);
diff --git a/etld/serialization.h b/etld/serialization.h
index 5233a9a..b91f7ec 100644
--- a/etld/serialization.h
+++ b/etld/serialization.h
@@ -14,16 +14,16 @@ namespace brave_etld {
 typedef std::string SerializedBuffer;
 typedef std::vector<SerializedBuffer> SerializedChildBuffers;
 
-struct SerializedBufferInfo {
-  size_t body_len;
+struct SerializationResult {
+  const SerializedBuffer buffer;
   size_t body_start;
-  size_t buffer_len;
+  size_t body_len;
 };
 
-struct SerializationResult {
-  SerializedBuffer buffer;
+struct SerializedBufferInfo {
   size_t body_len;
   size_t body_start;
+  size_t buffer_len;
 };
 
 SerializedBufferInfo extract_buffer_info(const SerializedBuffer &buffer);
diff --git a/etld/types.h b/etld/types.h
index 64105da..e19025f 100644
--- a/etld/types.h
+++ b/etld/types.h
@@ -11,14 +11,14 @@
 
 namespace brave_etld {
 
-typedef std::string Label;
-
 struct DomainInfo {
-  std::string tld;
-  std::string domain;
-  std::string subdomain;
+  const std::string tld;
+  const std::string domain;
+  const std::string subdomain;
 };
 
+typedef std::string Label;
+
 }  // namespace brave_etld
 
 #endif  // ETLD_TYPES_H_
diff --git a/muon/BUILD.gn b/muon/BUILD.gn
index 7db8f18..c5db2e0 100644
--- a/muon/BUILD.gn
+++ b/muon/BUILD.gn
@@ -48,12 +48,12 @@ source_set("ad_block") {
     "../etld/domain.h",
     "../etld/matcher.cc",
     "../etld/matcher.h",
-    "../etld/parser.cc",
-    "../etld/parser.h",
-    "../etld/public_suffix_rule.cc",
-    "../etld/public_suffix_rule.h",
-    "../etld/public_suffix_rule_set.cc",
-    "../etld/public_suffix_rule_set.h",
+    "../etld/internal/parser.cc",
+    "../etld/internal/parser.h",
+    "../etld/internal/public_suffix_rule.cc",
+    "../etld/internal/public_suffix_rule.h",
+    "../etld/internal/public_suffix_rule_set.cc",
+    "../etld/internal/public_suffix_rule_set.h",
     "../etld/serialization.cc",
     "../etld/serialization.h",
     "../etld/types.h",
diff --git a/perf/binding.gyp b/perf/binding.gyp
index c5aa478..0ba9bb6 100644
--- a/perf/binding.gyp
+++ b/perf/binding.gyp
@@ -16,12 +16,12 @@
       "../etld/domain.h",
       "../etld/matcher.cc",
       "../etld/matcher.h",
-      "../etld/parser.cc",
-      "../etld/parser.h",
-      "../etld/public_suffix_rule_set.cc",
-      "../etld/public_suffix_rule_set.h",
-      "../etld/public_suffix_rule.cc",
-      "../etld/public_suffix_rule.h",
+      "../etld/internal/parser.cc",
+      "../etld/internal/parser.h",
+      "../etld/internal/public_suffix_rule_set.cc",
+      "../etld/internal/public_suffix_rule_set.h",
+      "../etld/internal/public_suffix_rule.cc",
+      "../etld/internal/public_suffix_rule.h",
       "../etld/serialization.cc",
       "../etld/serialization.h",
       "../etld/types.h",
diff --git a/test/binding.gyp b/test/binding.gyp
index 0a91d49..73d8e19 100644
--- a/test/binding.gyp
+++ b/test/binding.gyp
@@ -4,26 +4,26 @@
     "type": "executable",
     "sources": [
       "../test/test_main.cc",
-      "../test/parser_test.cc",
-      "../test/options_test.cc",
-      "../test/rule_types_test.cc",
-      "../test/cosmetic_filter_test.cc",
-      "../test/protocol_test.cc",
-      "../test/orig_filters_test.cc",
+      # "../test/parser_test.cc",
+      # "../test/options_test.cc",
+      # "../test/rule_types_test.cc",
+      # "../test/cosmetic_filter_test.cc",
+      # "../test/protocol_test.cc",
+      # "../test/orig_filters_test.cc",
       "../test/etld_test.cc",
-      "../test/etld_serialization_test.cc",
-      "../test/etld_blocking_test.cc",
+      # "../test/etld_serialization_test.cc",
+      # "../test/etld_blocking_test.cc",
       "../test/util.cc",
       "../etld/domain.cc",
       "../etld/domain.h",
       "../etld/matcher.cc",
       "../etld/matcher.h",
-      "../etld/parser.cc",
-      "../etld/parser.h",
-      "../etld/public_suffix_rule.cc",
-      "../etld/public_suffix_rule.h",
-      "../etld/public_suffix_rule_set.cc",
-      "../etld/public_suffix_rule_set.h",
+      "../etld/internal/parser.cc",
+      "../etld/internal/parser.h",
+      "../etld/internal/public_suffix_rule.cc",
+      "../etld/internal/public_suffix_rule.h",
+      "../etld/internal/public_suffix_rule_set.cc",
+      "../etld/internal/public_suffix_rule_set.h",
       "../etld/serialization.cc",
       "../etld/serialization.h",
       "../etld/types.h",
diff --git a/test/etld_blocking_test.cc b/test/etld_blocking_test.cc
index 6b99f45..45c3474 100644
--- a/test/etld_blocking_test.cc
+++ b/test/etld_blocking_test.cc
@@ -11,14 +11,6 @@
 #include "./CppUnitLite/TestHarness.h"
 #include "./CppUnitLite/Test.h"
 #include "./ad_block_client.h"
-#include "./filter.h"
-#include "./etld/types.h"
-#include "./etld/matcher.h"
-#include "./etld/parser.h"
-#include "./etld/domain.h"
-#include "./etld/public_suffix_rule.h"
-#include "./etld/public_suffix_rule_set.h"
-#include "./etld/serialization.h"
 
 using std::string;
 
diff --git a/test/etld_serialization_test.cc b/test/etld_serialization_test.cc
index 7750905..17c9c43 100644
--- a/test/etld_serialization_test.cc
+++ b/test/etld_serialization_test.cc
@@ -11,22 +11,22 @@
 #include "./CppUnitLite/TestHarness.h"
 #include "./CppUnitLite/Test.h"
 #include "./ad_block_client.h"
+#include "./etld/internal/parser.h"
+#include "./etld/internal/public_suffix_rule.h"
+#include "./etld/internal/public_suffix_rule_set.h"
 #include "./etld/types.h"
 #include "./etld/matcher.h"
-#include "./etld/parser.h"
 #include "./etld/domain.h"
-#include "./etld/public_suffix_rule.h"
-#include "./etld/public_suffix_rule_set.h"
 #include "./etld/serialization.h"
 
 using std::string;
 using std::vector;
-using brave_etld::PublicSuffixRule;
-using brave_etld::PublicSuffixRuleSet;
+using brave_etld::internal::PublicSuffixRule;
+using brave_etld::internal::PublicSuffixRuleSet;
+using brave_etld::internal::rule_from_serialization;
+using brave_etld::internal::rule_set_from_serialization;
 using brave_etld::Matcher;
 using brave_etld::SerializationResult;
-using brave_etld::rule_from_serialization;
-using brave_etld::rule_set_from_serialization;
 using brave_etld::matcher_from_serialization;
 using brave_etld::SerializedBuffer;
 
diff --git a/test/etld_test.cc b/test/etld_test.cc
index ee57df1..3795bc9 100644
--- a/test/etld_test.cc
+++ b/test/etld_test.cc
@@ -10,31 +10,30 @@
 #include <fstream>
 #include "./CppUnitLite/TestHarness.h"
 #include "./CppUnitLite/Test.h"
+#include "./etld/internal/parser.h"
+#include "./etld/internal/public_suffix_rule.h"
+#include "./etld/internal/public_suffix_rule_set.h"
 #include "./etld/types.h"
 #include "./etld/matcher.h"
-#include "./etld/parser.h"
 #include "./etld/domain.h"
-#include "./etld/public_suffix_rule.h"
-#include "./etld/public_suffix_rule_set.h"
 
 using std::string;
 using std::cout;
 using std::endl;
 
-using brave_etld::PublicSuffixTextLineType;
-using brave_etld::PublicSuffixTextLineParseResult;
-using brave_etld::PublicSuffixRuleInputException;
-using brave_etld::PublicSuffixRuleSetMatchResult;
-using brave_etld::PublicSuffixRule;
-using brave_etld::PublicSuffixRuleSet;
+using brave_etld::internal::PublicSuffixTextLineType;
+using brave_etld::internal::PublicSuffixTextLineParseResult;
+using brave_etld::internal::PublicSuffixRuleInputException;
+using brave_etld::internal::PublicSuffixRuleSetMatchResult;
+using brave_etld::internal::PublicSuffixRule;
+using brave_etld::internal::PublicSuffixRuleSet;
+using brave_etld::internal::PublicSuffixParseResult;
+using brave_etld::internal::parse_rule_line;
+using brave_etld::internal::parse_rule_text;
+using brave_etld::internal::parse_rule_file;
 using brave_etld::Domain;
 using brave_etld::Matcher;
 using brave_etld::DomainInfo;
-using brave_etld::PublicSuffixParseResult;
-using brave_etld::parse_rule_line;
-using brave_etld::parse_rule_text;
-using brave_etld::parse_rule_file;
-
 
 bool testParsePublicSuffixTestLineNoOps(const string &line,
     PublicSuffixTextLineType expectedType) {
@@ -214,7 +213,13 @@ bool testPublicSuffixRuleSetMatch(const std::vector<string> &rules,
 
   Domain test_domain(domain_str);
   PublicSuffixRuleSetMatchResult match_result = rule_set.Match(test_domain);
-  string result_string = match_result.rule.DomainString();
+  if (match_result.found_match == false) {
+    cout << "Expected rule: '" << expected_match << "' "
+         << "to find a match, but received none." << endl;
+    return false;
+  }
+
+  string result_string = match_result.rule->DomainString();
   if (result_string != expected_match) {
     cout << "Expected rule: '" << expected_match << "' "
          << "to match '" << domain_str << "' "
@@ -225,6 +230,26 @@ bool testPublicSuffixRuleSetMatch(const std::vector<string> &rules,
   return true;
 }
 
+bool testPublicSuffixRuleSetNoMatch(const std::vector<string> &rules,
+    const string &domain_str) {
+  PublicSuffixRuleSet rule_set;
+  PublicSuffixRule rule;
+  for (auto &elm : rules) {
+    rule = PublicSuffixRule(elm);
+    rule_set.AddRule(rule);
+  }
+
+  Domain test_domain(domain_str);
+  PublicSuffixRuleSetMatchResult match_result = rule_set.Match(test_domain);
+  if (match_result.found_match == true) {
+    cout << "Did not expect rule: '" << domain_str << "' to match any "
+         << "rules, but found a match." << endl;
+    return false;
+  }
+
+  return true;
+}
+
 bool testPublicSuffixRuleTextApply(const string &rule_str,
     const string &domain_str, const DomainInfo &expected) {
   PublicSuffixRule rule(rule_str);
@@ -296,15 +321,15 @@ bool testPublicSuffixRuleFileApply(const string &file_path,
 TEST(eTLDParseRulesLine, basic) {
   CHECK(testParsePublicSuffixTestLineNoOps(
     "// this is an option",
-    brave_etld::PublicSuffixTextLineTypeComment));
+    brave_etld::internal::PublicSuffixTextLineTypeComment));
 
   CHECK(testParsePublicSuffixTestLineNoOps(
     "this.is.a.invalid..rule",
-    brave_etld::PublicSuffixTextLineTypeInvalidRule));
+    brave_etld::internal::PublicSuffixTextLineTypeInvalidRule));
 
   CHECK(testParsePublicSuffixTestLineNoOps(
     "",
-    brave_etld::PublicSuffixTextLineTypeWhitespace));
+    brave_etld::internal::PublicSuffixTextLineTypeWhitespace));
 
   // Since we read until the first white space, this will be read
   // as "example.", which is invalid because rules cannot hae empty labels
@@ -417,10 +442,9 @@ TEST(eTLDPublicSuffixRuleSetMatchTests, basic) {
     {"com", "*.jp", "*.hokkaido.jp"},
     "pete.hokkaido.jp",
     "*.hokkaido.jp"));
-  CHECK(testPublicSuffixRuleSetMatch(
+  CHECK(testPublicSuffixRuleSetNoMatch(
     {"com", "*.jp", "*.hokkaido.jp"},
-    "horse.shoes",
-    ""));
+    "horse.shoes"));
 }
 
 TEST(eTLDPublicSuffixRuleApplyTestTests, basic) {

From 454b9111693b7af88b12b648c58ee327d16760e8 Mon Sep 17 00:00:00 2001
From: Peter Snyder <snyderp@gmail.com>
Date: Sun, 24 Feb 2019 17:06:17 -0800
Subject: [PATCH 06/13] improve matching algorithm, be _way_ more careful about
 when copying / re-alloc-ing objects

---
 etld/domain.h                           |   2 +-
 etld/internal/public_suffix_rule.cc     |   6 +-
 etld/internal/public_suffix_rule.h      |   3 +
 etld/internal/public_suffix_rule_set.cc | 123 +++++++++++++++++++-----
 etld/internal/public_suffix_rule_set.h  |  37 ++++++-
 etld/matcher.cc                         |  13 +--
 etld/matcher.h                          |  12 +--
 etld/serialization.cc                   |   2 +
 etld/serialization.h                    |   5 +-
 test/binding.gyp                        |  16 +--
 10 files changed, 162 insertions(+), 57 deletions(-)

diff --git a/etld/domain.h b/etld/domain.h
index e060c29..fab254f 100644
--- a/etld/domain.h
+++ b/etld/domain.h
@@ -24,7 +24,7 @@ class Domain {
     return labels_.size();
   }
 
-  const Label& Get(std::size_t idx) const {
+  const Label& Get(size_t idx) const {
     return labels_[idx];
   }
 
diff --git a/etld/internal/public_suffix_rule.cc b/etld/internal/public_suffix_rule.cc
index a7a7c2b..3364d64 100644
--- a/etld/internal/public_suffix_rule.cc
+++ b/etld/internal/public_suffix_rule.cc
@@ -51,7 +51,7 @@ std::string trim_to_whitespace(std::string const& str) {
     return str;
   }
 
-  std::size_t first_scan = str.find_first_of(' ');
+  const size_t first_scan = str.find_first_of(' ');
   if (first_scan == std::string::npos) {
     return str;
   }
@@ -62,7 +62,7 @@ std::string trim_to_whitespace(std::string const& str) {
 PublicSuffixRule::PublicSuffixRule() {}
 
 PublicSuffixRule::PublicSuffixRule(const PublicSuffixRule &rule) :
-  labels_(rule.Labels()),
+  labels_(rule.labels_),
   is_exception_(rule.IsException()),
   is_wildcard_(rule.IsWildcard()) {}
 
@@ -73,7 +73,7 @@ PublicSuffixRule::PublicSuffixRule(const std::string &rule_text) {
       "Cannot create PublicSuffixRule from an empty string");
   }
 
-  std::size_t current = 0;
+  size_t current = 0;
   switch (trimmed_rule_text[0]) {
     case '*':
       is_wildcard_ = true;
diff --git a/etld/internal/public_suffix_rule.h b/etld/internal/public_suffix_rule.h
index 2aaf7d6..c5f5764 100644
--- a/etld/internal/public_suffix_rule.h
+++ b/etld/internal/public_suffix_rule.h
@@ -51,6 +51,9 @@ class PublicSuffixRule {
 
   const std::vector<Label>& Labels() const;
   size_t Length() const;
+  const Label& Get(size_t idx) const {
+    return labels_[idx];
+  }
 
   bool IsException() const {
     return is_exception_;
diff --git a/etld/internal/public_suffix_rule_set.cc b/etld/internal/public_suffix_rule_set.cc
index a6cfea2..6616d54 100644
--- a/etld/internal/public_suffix_rule_set.cc
+++ b/etld/internal/public_suffix_rule_set.cc
@@ -6,7 +6,7 @@
 #include <string>
 #include <sstream>
 #include <vector>
-#include <iostream>
+#include <map>
 #include "etld/internal/public_suffix_rule.h"
 #include "etld/internal/public_suffix_rule_set.h"
 #include "etld/domain.h"
@@ -20,12 +20,22 @@ namespace internal {
 
 PublicSuffixRuleSet::PublicSuffixRuleSet() {}
 
-PublicSuffixRuleSet::PublicSuffixRuleSet(const PublicSuffixRuleSet &rule_set) :
-  rules_(rule_set.Rules()) {}
+PublicSuffixRuleSet::PublicSuffixRuleSet(const PublicSuffixRuleSet &rule_set) {
+  for (auto &elm : rule_set.rules_) {
+    AddRule(*elm);
+  }
+}
 
 PublicSuffixRuleSet::PublicSuffixRuleSet(
-    const std::vector<PublicSuffixRule> &rules) : 
-  rules_(rules) {}
+    const std::vector<PublicSuffixRule> &rules) {
+  for (auto &elm : rules) {
+    AddRule(elm);
+  }
+}
+
+PublicSuffixRuleSet::~PublicSuffixRuleSet() {
+  delete root_;
+}
 
 bool PublicSuffixRuleSet::Equal(const PublicSuffixRuleSet &rule_set) const {
   if (rules_.size() != rule_set.rules_.size()) {
@@ -36,7 +46,7 @@ bool PublicSuffixRuleSet::Equal(const PublicSuffixRuleSet &rule_set) const {
   for (auto &local_elm : rules_) {
     found_match = false;
     for (auto &other_elm : rule_set.rules_) {
-     if (local_elm.Equals(other_elm)) {
+     if (local_elm->Equals(*other_elm)) {
        found_match = true;
        break;
      }
@@ -52,7 +62,7 @@ bool PublicSuffixRuleSet::Equal(const PublicSuffixRuleSet &rule_set) const {
 SerializationResult PublicSuffixRuleSet::Serialize() const {
   std::stringstream serialized_buffer;
   for (auto &elm : rules_) {
-    serialized_buffer << elm.Serialize().buffer;
+    serialized_buffer << elm->Serialize().buffer;
   }
 
   const std::string buffer_body = serialized_buffer.str();
@@ -79,32 +89,99 @@ SerializationResult PublicSuffixRuleSet::Serialize() const {
 
 PublicSuffixRuleSetMatchResult PublicSuffixRuleSet::Match(
     const Domain &domain) const {
-  int longest_length = -1;
-  int found_length;
-  const PublicSuffixRule * longest_rule;
-  for (auto &elm : rules_) {
-    if (elm.Matches(domain)) {
-      found_length = elm.Labels().size();
-      if (found_length > longest_length) {
-        longest_rule = &elm;
-        longest_length = found_length;
-      }
+  if (root_ == nullptr) {
+    return {false, nullptr};
+  }
+
+  const size_t domain_length = domain.Length();
+  if (domain_length == 0) {
+    return {false, nullptr};
+  }
+
+  std::vector<const PublicSuffixRule*>* matches = new std::vector<const PublicSuffixRule*>();
+  MatchRecursions(domain, domain_length - 1, matches, root_);
+
+  if (matches->size() == 0) {
+    delete matches;
+    return {false, nullptr};
+  }
+
+  size_t longest_length = 0;
+  size_t found_length;
+  const PublicSuffixRule* longest_match_result = nullptr;
+  for (auto &elm : *matches) {
+    found_length = elm->Length();
+    if (found_length > longest_length) {
+      longest_match_result = elm;
+      longest_length = found_length;
     }
   }
 
-  if (longest_length == -1) {
+  delete matches;
+  if (longest_match_result == nullptr) {
     return {false, nullptr};
   }
 
-  return {true, longest_rule};
+  return {true, longest_match_result};
 }
 
-void PublicSuffixRuleSet::AddRule(const PublicSuffixRule &rule) {
-  rules_.push_back(rule);
+void PublicSuffixRuleSet::MatchRecursions(const Domain &domain,
+    const size_t label_index, std::vector<const PublicSuffixRule*>* matches,
+    PublicSuffixRuleMapNode * node) const {
+  const Label& current_label = domain.Get(label_index);
+
+  const auto label_result = node->children->find(current_label);
+  if (label_result != node->children->end()) {
+    PublicSuffixRuleMapNode* child_node = node->children->at(current_label);
+    if (child_node->rule != nullptr) {
+      matches->push_back(child_node->rule);
+    }
+    if (label_index > 0) {
+      MatchRecursions(domain, label_index - 1, matches, child_node);
+    }
+  }
+
+  const auto wildcard_result = node->children->find("*");
+  if (wildcard_result != node->children->end()) {
+    PublicSuffixRuleMapNode* child_node = node->children->at("*");
+    if (child_node->rule != nullptr) {
+      matches->push_back(child_node->rule);
+    }
+    if (label_index > 0) {
+      MatchRecursions(domain, label_index - 1, matches, child_node);
+    }
+  }
+}
+
+void PublicSuffixRuleSet::AddRule(const PublicSuffixRule& rule) {
+  const int num_rules = static_cast<int>(rule.Length());
+  if (root_ == nullptr) {
+    root_ = new PublicSuffixRuleMapNode();
+  }
+  const size_t last_label_index = num_rules - 1;
+  AddRule(rule, last_label_index, root_);
 }
 
-const std::vector<PublicSuffixRule>& PublicSuffixRuleSet::Rules() const {
-  return rules_;
+void PublicSuffixRuleSet::AddRule(const PublicSuffixRule& rule,
+    const size_t label_index, PublicSuffixRuleMapNode* node) {
+  const Label& current_label = rule.Get(label_index);
+  const auto find_result = node->children->find(current_label);
+  PublicSuffixRuleMapNode *child_node;
+  if (find_result == node->children->end()) {
+    child_node = new PublicSuffixRuleMapNode();
+    node->children->emplace(current_label, child_node);
+  } else {
+    child_node = node->children->at(current_label);
+  }
+
+  if (label_index == 0) {
+    PublicSuffixRule* new_rule = new PublicSuffixRule(rule);
+    child_node->rule = new_rule;
+    rules_.push_back(new_rule);
+    return;
+  }
+  
+  AddRule(rule, label_index - 1, child_node);
 }
 
 PublicSuffixRuleSet rule_set_from_serialization(
diff --git a/etld/internal/public_suffix_rule_set.h b/etld/internal/public_suffix_rule_set.h
index 3a79078..40e6d35 100644
--- a/etld/internal/public_suffix_rule_set.h
+++ b/etld/internal/public_suffix_rule_set.h
@@ -8,33 +8,60 @@
 
 #include <string>
 #include <vector>
+#include <map>
 #include "etld/internal/public_suffix_rule.h"
 #include "etld/domain.h"
 #include "etld/types.h"
 #include "etld/serialization.h"
 
+using std::unique_ptr;
+
 namespace brave_etld {
 namespace internal {
 
 struct PublicSuffixRuleSetMatchResult {
-  bool found_match;
-  const PublicSuffixRule * rule;
+  const bool found_match;
+  const PublicSuffixRule* rule;
+};
+
+struct PublicSuffixRuleMapNode {
+  PublicSuffixRuleMapNode() {
+    children = new std::map<std::string, PublicSuffixRuleMapNode*>();
+  }
+  ~PublicSuffixRuleMapNode() {
+    for (auto &elm : *children) {
+      delete elm.second;
+    }
+    if (rule != nullptr) {
+      delete rule;
+    }
+  }
+  const PublicSuffixRule* rule = nullptr;
+  std::map<std::string, PublicSuffixRuleMapNode*>* children = nullptr;
 };
 
 class PublicSuffixRuleSet {
  public:
   PublicSuffixRuleSet();
+  ~PublicSuffixRuleSet();
   PublicSuffixRuleSet(const std::vector<PublicSuffixRule> &rules);
   PublicSuffixRuleSet(const PublicSuffixRuleSet &rule_set);
 
   SerializationResult Serialize() const;
   bool Equal(const PublicSuffixRuleSet &rule_set) const;
   PublicSuffixRuleSetMatchResult Match(const Domain &domain) const;
-  void AddRule(const PublicSuffixRule &rule);
-  const std::vector<PublicSuffixRule>& Rules() const;
+  void AddRule(const PublicSuffixRule& rule);
 
  private:
-  std::vector<PublicSuffixRule> rules_;
+  void AddRule(const PublicSuffixRule& rule, const size_t label_index,
+    PublicSuffixRuleMapNode* node);
+  void MatchRecursions(const Domain &domain,
+      const size_t label_index,
+      std::vector<const PublicSuffixRule*>* matches,
+      PublicSuffixRuleMapNode * node) const;
+
+  PublicSuffixRuleMapNode* root_ = nullptr;
+  std::vector<PublicSuffixRule*> rules_;
 };
 
 PublicSuffixRuleSet rule_set_from_serialization(const SerializedBuffer &buffer);
diff --git a/etld/matcher.cc b/etld/matcher.cc
index 754135a..157ee6c 100644
--- a/etld/matcher.cc
+++ b/etld/matcher.cc
@@ -13,10 +13,11 @@
 
 using brave_etld::internal::PublicSuffixParseResult;
 using brave_etld::internal::PublicSuffixRuleSetMatchResult;
+using brave_etld::internal::SerializedChildBuffers;
 
 namespace brave_etld {
 
-DomainInfo build_domain_info_(const internal::PublicSuffixRule * rule,
+DomainInfo build_domain_info(const internal::PublicSuffixRule* rule,
   const Domain &domain) {
   return rule->Apply(domain);
 }
@@ -71,7 +72,7 @@ SerializationResult Matcher::Serialize() const {
 
 bool Matcher::Equal(const Matcher &matcher) const {
   return (rules_.Equal(matcher.rules_) &&
-          exception_rules_.Equal(matcher.exception_rules_));
+    exception_rules_.Equal(matcher.exception_rules_));
 }
 
 // Attempts to implement the algoritms described here:
@@ -79,15 +80,15 @@ bool Matcher::Equal(const Matcher &matcher) const {
 DomainInfo Matcher::Match(const Domain &domain) const {
   PublicSuffixRuleSetMatchResult except_match = exception_rules_.Match(domain);
   if (except_match.found_match) {
-    return build_domain_info_(except_match.rule, domain);
+    return build_domain_info(except_match.rule, domain);
   }
 
   PublicSuffixRuleSetMatchResult rule_match = rules_.Match(domain);
   if (rule_match.found_match) {
-    return build_domain_info_(rule_match.rule, domain);
+    return build_domain_info(rule_match.rule, domain);
   }
 
-  return build_domain_info_(internal::PublicSuffixRule::root_rule, domain);
+  return build_domain_info(internal::PublicSuffixRule::root_rule, domain);
 }
 
 
@@ -102,7 +103,7 @@ void Matcher::ConsumeParseResult(const PublicSuffixParseResult &result) {
 }
 
 Matcher matcher_from_serialization(const SerializedBuffer &buffer) {
-  SerializedChildBuffers child_buffers = deserialize_buffer(buffer);
+  SerializedChildBuffers child_buffers = internal::deserialize_buffer(buffer);
   return {
     internal::rule_set_from_serialization(child_buffers[0]),
     internal::rule_set_from_serialization(child_buffers[1])
diff --git a/etld/matcher.h b/etld/matcher.h
index 77abbbf..98e8dc1 100644
--- a/etld/matcher.h
+++ b/etld/matcher.h
@@ -27,22 +27,14 @@ class Matcher {
   explicit Matcher(const internal::PublicSuffixParseResult &rules);
   Matcher(const internal::PublicSuffixRuleSet &rules,
     const internal::PublicSuffixRuleSet &exception_rules);
-
+  
   SerializationResult Serialize() const;
 
   bool Equal(const Matcher &matcher) const;
-  void ConsumeParseResult(const internal::PublicSuffixParseResult &result);
   DomainInfo Match(const Domain &domain) const;
 
-  size_t NumRules() const {
-    return rules_.Rules().size();
-  }
-
-  size_t NumExceptionRules() const {
-    return exception_rules_.Rules().size();
-  }
-
  private:
+  void ConsumeParseResult(const internal::PublicSuffixParseResult &result);
   internal::PublicSuffixRuleSet rules_;
   internal::PublicSuffixRuleSet exception_rules_;
 };
diff --git a/etld/serialization.cc b/etld/serialization.cc
index cba5f88..2ef8b35 100644
--- a/etld/serialization.cc
+++ b/etld/serialization.cc
@@ -9,6 +9,7 @@
 #include "etld/serialization.h"
 
 namespace brave_etld {
+namespace internal {
 
 SerializedBufferInfo extract_buffer_info(const SerializedBuffer &buffer) {
   SerializedBufferInfo info;
@@ -47,4 +48,5 @@ SerializedChildBuffers deserialize_buffer(const SerializedBuffer &buffer) {
   return child_buffers;
 }
 
+}  // namespace internal
 }  // namespace brave_etld
diff --git a/etld/serialization.h b/etld/serialization.h
index b91f7ec..2ec9ded 100644
--- a/etld/serialization.h
+++ b/etld/serialization.h
@@ -12,7 +12,6 @@
 namespace brave_etld {
 
 typedef std::string SerializedBuffer;
-typedef std::vector<SerializedBuffer> SerializedChildBuffers;
 
 struct SerializationResult {
   const SerializedBuffer buffer;
@@ -20,15 +19,19 @@ struct SerializationResult {
   size_t body_len;
 };
 
+namespace internal {
+
 struct SerializedBufferInfo {
   size_t body_len;
   size_t body_start;
   size_t buffer_len;
 };
 
+typedef std::vector<SerializedBuffer> SerializedChildBuffers;
 SerializedBufferInfo extract_buffer_info(const SerializedBuffer &buffer);
 SerializedChildBuffers deserialize_buffer(const SerializedBuffer &buffer);
 
+}  // namespace internal
 }  // namespace brave_etld
 
 #endif  // ETLD_SERIALIZATION_H_
diff --git a/test/binding.gyp b/test/binding.gyp
index 73d8e19..6f02e5b 100644
--- a/test/binding.gyp
+++ b/test/binding.gyp
@@ -4,15 +4,15 @@
     "type": "executable",
     "sources": [
       "../test/test_main.cc",
-      # "../test/parser_test.cc",
-      # "../test/options_test.cc",
-      # "../test/rule_types_test.cc",
-      # "../test/cosmetic_filter_test.cc",
-      # "../test/protocol_test.cc",
-      # "../test/orig_filters_test.cc",
+      "../test/parser_test.cc",
+      "../test/options_test.cc",
+      "../test/rule_types_test.cc",
+      "../test/cosmetic_filter_test.cc",
+      "../test/protocol_test.cc",
+      "../test/orig_filters_test.cc",
       "../test/etld_test.cc",
-      # "../test/etld_serialization_test.cc",
-      # "../test/etld_blocking_test.cc",
+      "../test/etld_serialization_test.cc",
+      "../test/etld_blocking_test.cc",
       "../test/util.cc",
       "../etld/domain.cc",
       "../etld/domain.h",

From d4a963530e2fa95bec4cea4464068b08bd154b9d Mon Sep 17 00:00:00 2001
From: Peter Snyder <snyderp@gmail.com>
Date: Sun, 24 Feb 2019 17:38:26 -0800
Subject: [PATCH 07/13] remove final malloc / new in matching process

---
 etld/internal/public_suffix_rule_set.cc | 52 ++++++++++---------------
 etld/internal/public_suffix_rule_set.h  | 14 +++----
 2 files changed, 26 insertions(+), 40 deletions(-)

diff --git a/etld/internal/public_suffix_rule_set.cc b/etld/internal/public_suffix_rule_set.cc
index 6616d54..cf61468 100644
--- a/etld/internal/public_suffix_rule_set.cc
+++ b/etld/internal/public_suffix_rule_set.cc
@@ -7,6 +7,7 @@
 #include <sstream>
 #include <vector>
 #include <map>
+#include <iostream>
 #include "etld/internal/public_suffix_rule.h"
 #include "etld/internal/public_suffix_rule_set.h"
 #include "etld/domain.h"
@@ -20,14 +21,14 @@ namespace internal {
 
 PublicSuffixRuleSet::PublicSuffixRuleSet() {}
 
-PublicSuffixRuleSet::PublicSuffixRuleSet(const PublicSuffixRuleSet &rule_set) {
+PublicSuffixRuleSet::PublicSuffixRuleSet(const PublicSuffixRuleSet& rule_set) {
   for (auto &elm : rule_set.rules_) {
     AddRule(*elm);
   }
 }
 
 PublicSuffixRuleSet::PublicSuffixRuleSet(
-    const std::vector<PublicSuffixRule> &rules) {
+    const std::vector<PublicSuffixRule>& rules) {
   for (auto &elm : rules) {
     AddRule(elm);
   }
@@ -37,7 +38,7 @@ PublicSuffixRuleSet::~PublicSuffixRuleSet() {
   delete root_;
 }
 
-bool PublicSuffixRuleSet::Equal(const PublicSuffixRuleSet &rule_set) const {
+bool PublicSuffixRuleSet::Equal(const PublicSuffixRuleSet& rule_set) const {
   if (rules_.size() != rule_set.rules_.size()) {
     return false;
   }
@@ -88,7 +89,7 @@ SerializationResult PublicSuffixRuleSet::Serialize() const {
 }
 
 PublicSuffixRuleSetMatchResult PublicSuffixRuleSet::Match(
-    const Domain &domain) const {
+    const Domain& domain) const {
   if (root_ == nullptr) {
     return {false, nullptr};
   }
@@ -98,46 +99,31 @@ PublicSuffixRuleSetMatchResult PublicSuffixRuleSet::Match(
     return {false, nullptr};
   }
 
-  std::vector<const PublicSuffixRule*>* matches = new std::vector<const PublicSuffixRule*>();
-  MatchRecursions(domain, domain_length - 1, matches, root_);
+  const PublicSuffixRule* match = nullptr;
+  MatchRecursions(domain, domain_length - 1, &match, root_);
 
-  if (matches->size() == 0) {
-    delete matches;
+  if (match == nullptr) {
     return {false, nullptr};
   }
 
-  size_t longest_length = 0;
-  size_t found_length;
-  const PublicSuffixRule* longest_match_result = nullptr;
-  for (auto &elm : *matches) {
-    found_length = elm->Length();
-    if (found_length > longest_length) {
-      longest_match_result = elm;
-      longest_length = found_length;
-    }
-  }
-
-  delete matches;
-  if (longest_match_result == nullptr) {
-    return {false, nullptr};
-  }
-
-  return {true, longest_match_result};
+  return {true, match};
 }
 
-void PublicSuffixRuleSet::MatchRecursions(const Domain &domain,
-    const size_t label_index, std::vector<const PublicSuffixRule*>* matches,
-    PublicSuffixRuleMapNode * node) const {
+void PublicSuffixRuleSet::MatchRecursions(const Domain& domain,
+    const size_t label_index, const PublicSuffixRule** match,
+    PublicSuffixRuleMapNode* node) const {
   const Label& current_label = domain.Get(label_index);
 
   const auto label_result = node->children->find(current_label);
   if (label_result != node->children->end()) {
     PublicSuffixRuleMapNode* child_node = node->children->at(current_label);
     if (child_node->rule != nullptr) {
-      matches->push_back(child_node->rule);
+      if (*match == nullptr || child_node->rule->Length() > (*match)->Length()) {
+        *match = child_node->rule;
+      }
     }
     if (label_index > 0) {
-      MatchRecursions(domain, label_index - 1, matches, child_node);
+      MatchRecursions(domain, label_index - 1, match, child_node);
     }
   }
 
@@ -145,10 +131,12 @@ void PublicSuffixRuleSet::MatchRecursions(const Domain &domain,
   if (wildcard_result != node->children->end()) {
     PublicSuffixRuleMapNode* child_node = node->children->at("*");
     if (child_node->rule != nullptr) {
-      matches->push_back(child_node->rule);
+      if (*match == nullptr || child_node->rule->Length() > (*match)->Length()) {
+        *match = child_node->rule;
+      }
     }
     if (label_index > 0) {
-      MatchRecursions(domain, label_index - 1, matches, child_node);
+      MatchRecursions(domain, label_index - 1, match, child_node);
     }
   }
 }
diff --git a/etld/internal/public_suffix_rule_set.h b/etld/internal/public_suffix_rule_set.h
index 40e6d35..38d7218 100644
--- a/etld/internal/public_suffix_rule_set.h
+++ b/etld/internal/public_suffix_rule_set.h
@@ -44,21 +44,19 @@ class PublicSuffixRuleSet {
  public:
   PublicSuffixRuleSet();
   ~PublicSuffixRuleSet();
-  PublicSuffixRuleSet(const std::vector<PublicSuffixRule> &rules);
-  PublicSuffixRuleSet(const PublicSuffixRuleSet &rule_set);
+  PublicSuffixRuleSet(const std::vector<PublicSuffixRule>& rules);
+  PublicSuffixRuleSet(const PublicSuffixRuleSet& rule_set);
 
   SerializationResult Serialize() const;
-  bool Equal(const PublicSuffixRuleSet &rule_set) const;
-  PublicSuffixRuleSetMatchResult Match(const Domain &domain) const;
+  bool Equal(const PublicSuffixRuleSet& rule_set) const;
+  PublicSuffixRuleSetMatchResult Match(const Domain& domain) const;
   void AddRule(const PublicSuffixRule& rule);
 
  private:
   void AddRule(const PublicSuffixRule& rule, const size_t label_index,
     PublicSuffixRuleMapNode* node);
-  void MatchRecursions(const Domain &domain,
-      const size_t label_index,
-      std::vector<const PublicSuffixRule*>* matches,
-      PublicSuffixRuleMapNode * node) const;
+  void MatchRecursions(const Domain &domain, const size_t label_index,
+      const PublicSuffixRule** match, PublicSuffixRuleMapNode* node) const;
 
   PublicSuffixRuleMapNode* root_ = nullptr;
   std::vector<PublicSuffixRule*> rules_;

From 42ae4f485d6a607d0fdbc2b3ad9431d809144dfe Mon Sep 17 00:00:00 2001
From: Peter Snyder <snyderp@gmail.com>
Date: Sun, 24 Feb 2019 17:53:35 -0800
Subject: [PATCH 08/13] linter fixes / cleanup

---
 ad_block_client.cc                      |  3 +-
 etld/domain.cc                          | 12 ++++----
 etld/domain.h                           |  6 ++--
 etld/internal/parser.cc                 | 17 ++++++-----
 etld/internal/parser.h                  | 12 ++++----
 etld/internal/public_suffix_rule.cc     | 25 ++++++++--------
 etld/internal/public_suffix_rule.h      | 20 ++++++-------
 etld/internal/public_suffix_rule_set.cc | 12 ++++----
 etld/internal/public_suffix_rule_set.h  |  6 ++--
 etld/matcher.cc                         | 28 +++++++++---------
 etld/matcher.h                          | 20 ++++++-------
 etld/serialization.cc                   | 38 ++++++++++++++-----------
 etld/serialization.h                    | 14 ++++-----
 test/etld_blocking_test.cc              |  2 +-
 test/etld_test.cc                       |  4 +--
 15 files changed, 110 insertions(+), 109 deletions(-)

diff --git a/ad_block_client.cc b/ad_block_client.cc
index 2df8a94..24aeeb0 100644
--- a/ad_block_client.cc
+++ b/ad_block_client.cc
@@ -874,7 +874,7 @@ bool AdBlockClient::matches(const char* input, FilterOption contextOption,
 
   if (isNoFingerprintDomainHashSetMiss(
         noFingerprintAntiDomainExceptionHashSet, contextDomain,
-        contextDomainLen )) {
+        contextDomainLen)) {
     hasExceptionMatch = hasExceptionMatch ||
     hasMatchingFilters(noFingerprintAntiDomainOnlyExceptionFilters,
       numNoFingerprintAntiDomainOnlyExceptionFilters, input, inputLen,
@@ -1566,7 +1566,6 @@ char * AdBlockClient::serialize(int *totalSize,
           &noFingerprintAntiDomainExceptionHashSetSize);
   }
 
-  
   SerializedBuffer serializedMatcherBuffer;
   int serializedMatcherBufSize;
   if (etldMatcher == nullptr) {
diff --git a/etld/domain.cc b/etld/domain.cc
index 8e52d94..7bc7bad 100644
--- a/etld/domain.cc
+++ b/etld/domain.cc
@@ -3,20 +3,20 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+#include "etld/domain.h"
 #include <string>
 #include <sstream>
-#include "etld/domain.h"
 
 namespace brave_etld {
 
-Domain::Domain(const Domain &domain) :
+Domain::Domain(const Domain& domain) :
   labels_(domain.labels_) {}
 
-Domain::Domain(const std::vector<Label> &labels) :
+Domain::Domain(const std::vector<Label>& labels) :
   labels_(labels) {}
 
-Domain::Domain(const std::string &string) {
-  std::size_t current, previous = 0;
+Domain::Domain(const std::string& string) {
+  size_t current, previous = 0;
   current = string.find(".");
   if (current == std::string::npos) {
     labels_.push_back(string);
@@ -34,7 +34,7 @@ Domain::Domain(const std::string &string) {
   }
 }
 
-bool Domain::Equals(const Domain &domain) {
+bool Domain::Equals(const Domain& domain) {
   const size_t local_length = Length();
   if (local_length != domain.Length()) {
     return false;
diff --git a/etld/domain.h b/etld/domain.h
index fab254f..0d121ba 100644
--- a/etld/domain.h
+++ b/etld/domain.h
@@ -14,9 +14,9 @@ namespace brave_etld {
 
 class Domain {
  public:
-  explicit Domain(const Domain &domain);
-  explicit Domain(const std::string &domain);
-  explicit Domain(const std::vector<Label> &labels);
+  explicit Domain(const Domain& domain);
+  explicit Domain(const std::string& domain);
+  explicit Domain(const std::vector<Label>& labels);
 
   bool Equals(const Domain &domain);
 
diff --git a/etld/internal/parser.cc b/etld/internal/parser.cc
index c97a691..b54977f 100644
--- a/etld/internal/parser.cc
+++ b/etld/internal/parser.cc
@@ -3,11 +3,11 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+#include "etld/internal/parser.h"
 #include <string>
 #include <sstream>
 #include <fstream>
 #include <vector>
-#include "etld/internal/parser.h"
 #include "etld/internal/public_suffix_rule.h"
 #include "etld/types.h"
 
@@ -17,7 +17,7 @@ namespace internal {
 PublicSuffixParseResult::PublicSuffixParseResult() {}
 
 PublicSuffixParseResult::PublicSuffixParseResult(
-    const PublicSuffixParseResult &results) :
+    const PublicSuffixParseResult& results) :
   num_whitespace_lines_(results.num_whitespace_lines_),
   num_comment_lines_(results.num_comment_lines_),
   num_invalid_rules_(results.num_invalid_rules_),
@@ -28,7 +28,7 @@ const std::vector<PublicSuffixRule>& PublicSuffixParseResult::Rules() const {
 }
 
 void PublicSuffixParseResult::ConsumeParseResult(
-    const PublicSuffixTextLineParseResult &result) {
+    const PublicSuffixTextLineParseResult& result) {
   switch (result.type) {
     case PublicSuffixTextLineTypeRule:
       rules_.push_back(*(result.rule));
@@ -52,17 +52,17 @@ void PublicSuffixParseResult::ConsumeParseResult(
   }
 }
 
-PublicSuffixParseResult parse_rule_file(std::ifstream &rule_file) {
+PublicSuffixParseResult parse_rule_file(std::ifstream* rule_file) {
   std::string line;
   PublicSuffixParseResult results;
-  while (std::getline(rule_file, line)) {
+  while (std::getline(*rule_file, line)) {
     results.ConsumeParseResult(parse_rule_line(line));
   }
 
   return results;
 }
 
-PublicSuffixParseResult parse_rule_text(const std::string &text) {
+PublicSuffixParseResult parse_rule_text(const std::string& text) {
   std::istringstream stream(text);
   std::string line;
   PublicSuffixParseResult results;
@@ -73,7 +73,7 @@ PublicSuffixParseResult parse_rule_text(const std::string &text) {
   return results;
 }
 
-PublicSuffixTextLineParseResult parse_rule_line(const std::string &line) {
+PublicSuffixTextLineParseResult parse_rule_line(const std::string& line) {
   // Check to see if this is a comment line.  If so, process no further.
   if (line.find("//") == 0) {
     return PublicSuffixTextLineParseResult(PublicSuffixTextLineTypeComment);
@@ -88,8 +88,7 @@ PublicSuffixTextLineParseResult parse_rule_line(const std::string &line) {
   try {
     return PublicSuffixTextLineParseResult(
       PublicSuffixTextLineTypeRule,
-      new PublicSuffixRule(line)
-    );
+      new PublicSuffixRule(line));
   } catch (PublicSuffixRuleInputException error) {
     return PublicSuffixTextLineParseResult(PublicSuffixTextLineTypeInvalidRule);
   }
diff --git a/etld/internal/parser.h b/etld/internal/parser.h
index 9aab96d..f5a6280 100644
--- a/etld/internal/parser.h
+++ b/etld/internal/parser.h
@@ -26,7 +26,7 @@ enum PublicSuffixTextLineType {
 struct PublicSuffixTextLineParseResult {
   PublicSuffixTextLineParseResult(
       PublicSuffixTextLineType type = PublicSuffixTextLineTypeNone,
-      const PublicSuffixRule * rule = nullptr) : 
+      const PublicSuffixRule* rule = nullptr) :
     type(type),
     rule(rule) {}
   const PublicSuffixTextLineType type;
@@ -36,10 +36,10 @@ struct PublicSuffixTextLineParseResult {
 class PublicSuffixParseResult {
  public:
   PublicSuffixParseResult();
-  PublicSuffixParseResult(const PublicSuffixParseResult &results);
+  PublicSuffixParseResult(const PublicSuffixParseResult& results);
 
   const std::vector<PublicSuffixRule>& Rules() const;
-  void ConsumeParseResult(const PublicSuffixTextLineParseResult &result);
+  void ConsumeParseResult(const PublicSuffixTextLineParseResult& result);
 
   int NumWhitespaceLines() const {
     return num_whitespace_lines_;
@@ -62,9 +62,9 @@ class PublicSuffixParseResult {
 
 // This attempts to implement the algorithm described here:
 //   https://www.publicsuffix.org/list/
-PublicSuffixParseResult parse_rule_file(std::ifstream &rule_file);
-PublicSuffixParseResult parse_rule_text(const std::string &rule_text);
-PublicSuffixTextLineParseResult parse_rule_line(const std::string &line);
+PublicSuffixParseResult parse_rule_file(std::ifstream* rule_file);
+PublicSuffixParseResult parse_rule_text(const std::string& rule_text);
+PublicSuffixTextLineParseResult parse_rule_line(const std::string& line);
 
 }  // namespace internal
 }  // namespace brave_etld
diff --git a/etld/internal/public_suffix_rule.cc b/etld/internal/public_suffix_rule.cc
index 3364d64..e2c75e1 100644
--- a/etld/internal/public_suffix_rule.cc
+++ b/etld/internal/public_suffix_rule.cc
@@ -3,22 +3,21 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+#include "etld/internal/public_suffix_rule.h"
 #include <string>
 #include <sstream>
 #include <vector>
 #include <cstdio>
-#include <iostream>
 #include "etld/domain.h"
-#include "etld/internal/public_suffix_rule.h"
 #include "etld/types.h"
 #include "etld/serialization.h"
 
 namespace brave_etld {
 namespace internal {
 
-const PublicSuffixRule * PublicSuffixRule::root_rule = new PublicSuffixRule("*");
+const PublicSuffixRule* PublicSuffixRule::root_rule = new PublicSuffixRule("*");
 
-std::vector<Label> parse_labels(const std::string &label_text) {
+std::vector<Label> parse_labels(const std::string& label_text) {
   std::vector<Label> labels;
   size_t previous = 0;
   size_t current = label_text.find(".");
@@ -61,12 +60,12 @@ std::string trim_to_whitespace(std::string const& str) {
 
 PublicSuffixRule::PublicSuffixRule() {}
 
-PublicSuffixRule::PublicSuffixRule(const PublicSuffixRule &rule) :
+PublicSuffixRule::PublicSuffixRule(const PublicSuffixRule& rule) :
   labels_(rule.labels_),
   is_exception_(rule.IsException()),
   is_wildcard_(rule.IsWildcard()) {}
 
-PublicSuffixRule::PublicSuffixRule(const std::string &rule_text) {
+PublicSuffixRule::PublicSuffixRule(const std::string& rule_text) {
   std::string trimmed_rule_text(trim_to_whitespace(rule_text));
   if (trimmed_rule_text.length() == 0) {
     throw PublicSuffixRuleInputException(
@@ -97,7 +96,7 @@ PublicSuffixRule::PublicSuffixRule(const std::string &rule_text) {
   labels_ = parse_labels(labels_view);
 }
 
-PublicSuffixRule::PublicSuffixRule(const std::vector<Label> &labels,
+PublicSuffixRule::PublicSuffixRule(const std::vector<Label>& labels,
   bool is_exception, bool is_wildcard) :
     labels_(labels),
     is_exception_(is_exception),
@@ -111,7 +110,7 @@ SerializationResult PublicSuffixRule::Serialize() const {
   const size_t header_len = header_str.size();
   const size_t body_start = header_len + 1;
   const uint buffer_size = body_start + body_len + 1;
-  char buffer[buffer_size];
+  char* buffer = reinterpret_cast<char*>(malloc(sizeof(char) * buffer_size));
 
   snprintf(
     buffer,
@@ -129,7 +128,7 @@ SerializationResult PublicSuffixRule::Serialize() const {
   };
 }
 
-bool PublicSuffixRule::Equals(const PublicSuffixRule &rule) const {
+bool PublicSuffixRule::Equals(const PublicSuffixRule& rule) const {
   return (
     labels_ == rule.labels_ &&
     is_exception_ == rule.IsException() &&
@@ -138,7 +137,7 @@ bool PublicSuffixRule::Equals(const PublicSuffixRule &rule) const {
 
 // Implements matching algoritms described here
 //   https://publicsuffix.org/list/
-bool PublicSuffixRule::Matches(const Domain &domain) const {
+bool PublicSuffixRule::Matches(const Domain& domain) const {
   // When the domain and rule are split into corresponding labels, that the
   // domain contains as many or more labels than the rule.
   const size_t num_rule_labels = labels_.size();
@@ -166,8 +165,8 @@ bool PublicSuffixRule::Matches(const Domain &domain) const {
   return true;
 }
 
-DomainInfo PublicSuffixRule::Apply(const Domain &domain) const {
-  auto domain_len = domain.Length();
+DomainInfo PublicSuffixRule::Apply(const Domain& domain) const {
+  const auto domain_len = domain.Length();
   auto rule_len = Length();
   if (IsException()) {
     rule_len -= 1;
@@ -249,7 +248,7 @@ std::string PublicSuffixRule::ToString() const {
   return as_string.str();
 }
 
-PublicSuffixRule rule_from_serialization(const SerializedBuffer &buffer) {
+PublicSuffixRule rule_from_serialization(const SerializedBuffer& buffer) {
   const SerializedBufferInfo info = extract_buffer_info(buffer);
   const std::string body_str = buffer.substr(info.body_start, info.body_len);
   bool is_exception = body_str[0] == 't';
diff --git a/etld/internal/public_suffix_rule.h b/etld/internal/public_suffix_rule.h
index c5f5764..262dc12 100644
--- a/etld/internal/public_suffix_rule.h
+++ b/etld/internal/public_suffix_rule.h
@@ -17,7 +17,7 @@ namespace internal {
 
 class PublicSuffixRuleInputException : public std::exception {
  public:
-  explicit PublicSuffixRuleInputException(const char * message) :
+  explicit PublicSuffixRuleInputException(const char* message) :
     msg_(message) {}
   explicit PublicSuffixRuleInputException(const std::string &message) :
     msg_(message) {}
@@ -32,20 +32,20 @@ class PublicSuffixRuleInputException : public std::exception {
 
 class PublicSuffixRule {
  public:
-  static const PublicSuffixRule * root_rule;
+  static const PublicSuffixRule* root_rule;
   PublicSuffixRule();
-  PublicSuffixRule(const PublicSuffixRule &rule);
-  explicit PublicSuffixRule(const std::string &rule_text);
+  PublicSuffixRule(const PublicSuffixRule& rule);
+  explicit PublicSuffixRule(const std::string& rule_text);
   PublicSuffixRule(
-    const std::vector<Label> &labels,
+    const std::vector<Label>& labels,
     bool is_exception = false,
     bool is_wildcard = false);
 
   SerializationResult Serialize() const;
 
-  bool Equals(const PublicSuffixRule &rule) const;
-  bool Matches(const Domain &domain) const;
-  DomainInfo Apply(const Domain &domain) const;
+  bool Equals(const PublicSuffixRule& rule) const;
+  bool Matches(const Domain& domain) const;
+  DomainInfo Apply(const Domain& domain) const;
   std::string ToString() const;
   std::string DomainString() const;
 
@@ -68,8 +68,8 @@ class PublicSuffixRule {
   bool is_wildcard_ = false;
 };
 
-PublicSuffixRule rule_from_serialization(const SerializedBuffer &buffer);
-std::vector<Label> parse_labels(const std::string &label_text);
+PublicSuffixRule rule_from_serialization(const SerializedBuffer& buffer);
+std::vector<Label> parse_labels(const std::string& label_text);
 
 }  // namespace internal
 }  // namespace brave_etld
diff --git a/etld/internal/public_suffix_rule_set.cc b/etld/internal/public_suffix_rule_set.cc
index cf61468..95bafd9 100644
--- a/etld/internal/public_suffix_rule_set.cc
+++ b/etld/internal/public_suffix_rule_set.cc
@@ -72,7 +72,7 @@ SerializationResult PublicSuffixRuleSet::Serialize() const {
   const size_t header_len = header_str.size();
   const size_t body_start = header_len + 1;
   const size_t buffer_size = body_start + body_len + 1;
-  char buffer[buffer_size];
+  char* buffer = reinterpret_cast<char*>(malloc(sizeof(char) * buffer_size));
 
   snprintf(
     buffer,
@@ -118,7 +118,8 @@ void PublicSuffixRuleSet::MatchRecursions(const Domain& domain,
   if (label_result != node->children->end()) {
     PublicSuffixRuleMapNode* child_node = node->children->at(current_label);
     if (child_node->rule != nullptr) {
-      if (*match == nullptr || child_node->rule->Length() > (*match)->Length()) {
+      if (*match == nullptr ||
+          child_node->rule->Length() > (*match)->Length()) {
         *match = child_node->rule;
       }
     }
@@ -131,7 +132,8 @@ void PublicSuffixRuleSet::MatchRecursions(const Domain& domain,
   if (wildcard_result != node->children->end()) {
     PublicSuffixRuleMapNode* child_node = node->children->at("*");
     if (child_node->rule != nullptr) {
-      if (*match == nullptr || child_node->rule->Length() > (*match)->Length()) {
+      if (*match == nullptr ||
+          child_node->rule->Length() > (*match)->Length()) {
         *match = child_node->rule;
       }
     }
@@ -168,12 +170,12 @@ void PublicSuffixRuleSet::AddRule(const PublicSuffixRule& rule,
     rules_.push_back(new_rule);
     return;
   }
-  
+
   AddRule(rule, label_index - 1, child_node);
 }
 
 PublicSuffixRuleSet rule_set_from_serialization(
-    const SerializedBuffer &buffer) {
+    const SerializedBuffer& buffer) {
   std::vector<PublicSuffixRule> rules;
   for (auto &elm : deserialize_buffer(buffer)) {
     rules.push_back(rule_from_serialization(elm));
diff --git a/etld/internal/public_suffix_rule_set.h b/etld/internal/public_suffix_rule_set.h
index 38d7218..7e7d630 100644
--- a/etld/internal/public_suffix_rule_set.h
+++ b/etld/internal/public_suffix_rule_set.h
@@ -6,16 +6,14 @@
 #ifndef ETLD_INTERNAL_PUBLIC_SUFFIX_RULE_SET_H_
 #define ETLD_INTERNAL_PUBLIC_SUFFIX_RULE_SET_H_
 
+#include "etld/internal/public_suffix_rule.h"
 #include <string>
 #include <vector>
 #include <map>
-#include "etld/internal/public_suffix_rule.h"
 #include "etld/domain.h"
 #include "etld/types.h"
 #include "etld/serialization.h"
 
-using std::unique_ptr;
-
 namespace brave_etld {
 namespace internal {
 
@@ -44,7 +42,7 @@ class PublicSuffixRuleSet {
  public:
   PublicSuffixRuleSet();
   ~PublicSuffixRuleSet();
-  PublicSuffixRuleSet(const std::vector<PublicSuffixRule>& rules);
+  explicit PublicSuffixRuleSet(const std::vector<PublicSuffixRule>& rules);
   PublicSuffixRuleSet(const PublicSuffixRuleSet& rule_set);
 
   SerializationResult Serialize() const;
diff --git a/etld/matcher.cc b/etld/matcher.cc
index 157ee6c..010f1cc 100644
--- a/etld/matcher.cc
+++ b/etld/matcher.cc
@@ -3,12 +3,13 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+#include "etld/matcher.h"
+#include <stdlib.h>
 #include <fstream>
 #include <sstream>
 #include "etld/types.h"
 #include "etld/internal/parser.h"
 #include "etld/internal/public_suffix_rule.h"
-#include "etld/matcher.h"
 #include "etld/serialization.h"
 
 using brave_etld::internal::PublicSuffixParseResult;
@@ -18,28 +19,28 @@ using brave_etld::internal::SerializedChildBuffers;
 namespace brave_etld {
 
 DomainInfo build_domain_info(const internal::PublicSuffixRule* rule,
-  const Domain &domain) {
+  const Domain& domain) {
   return rule->Apply(domain);
 }
 
-Matcher::Matcher(std::ifstream &rule_file) {
+Matcher::Matcher(std::ifstream* rule_file) {
   ConsumeParseResult(internal::parse_rule_file(rule_file));
 }
 
-Matcher::Matcher(const std::string &rule_text) {
+Matcher::Matcher(const std::string& rule_text) {
   ConsumeParseResult(internal::parse_rule_text(rule_text));
 }
 
-Matcher::Matcher(const PublicSuffixParseResult &rules) {
+Matcher::Matcher(const PublicSuffixParseResult& rules) {
   ConsumeParseResult(rules);
 }
 
-Matcher::Matcher(const Matcher &matcher) :
+Matcher::Matcher(const Matcher& matcher) :
   rules_(matcher.rules_),
   exception_rules_(matcher.exception_rules_) {}
 
-Matcher::Matcher(const internal::PublicSuffixRuleSet &rules,
-    const internal::PublicSuffixRuleSet &exception_rules) :
+Matcher::Matcher(const internal::PublicSuffixRuleSet& rules,
+    const internal::PublicSuffixRuleSet& exception_rules) :
   rules_(rules),
   exception_rules_(exception_rules) {}
 
@@ -54,7 +55,7 @@ SerializationResult Matcher::Serialize() const {
   const size_t header_len = header_str.size();
   const size_t body_start = header_len + 1;
   const size_t buffer_size = body_start + body_len + 1;
-  char buffer[buffer_size];
+  char* buffer = reinterpret_cast<char*>(malloc(sizeof(char) * buffer_size));
 
   snprintf(
     buffer,
@@ -70,14 +71,14 @@ SerializationResult Matcher::Serialize() const {
   };
 }
 
-bool Matcher::Equal(const Matcher &matcher) const {
+bool Matcher::Equal(const Matcher& matcher) const {
   return (rules_.Equal(matcher.rules_) &&
     exception_rules_.Equal(matcher.exception_rules_));
 }
 
 // Attempts to implement the algoritms described here:
 //   https://publicsuffix.org/list/
-DomainInfo Matcher::Match(const Domain &domain) const {
+DomainInfo Matcher::Match(const Domain& domain) const {
   PublicSuffixRuleSetMatchResult except_match = exception_rules_.Match(domain);
   if (except_match.found_match) {
     return build_domain_info(except_match.rule, domain);
@@ -91,8 +92,7 @@ DomainInfo Matcher::Match(const Domain &domain) const {
   return build_domain_info(internal::PublicSuffixRule::root_rule, domain);
 }
 
-
-void Matcher::ConsumeParseResult(const PublicSuffixParseResult &result) {
+void Matcher::ConsumeParseResult(const PublicSuffixParseResult& result) {
   for (auto &elm : result.Rules()) {
     if (elm.IsException()) {
       exception_rules_.AddRule(elm);
@@ -102,7 +102,7 @@ void Matcher::ConsumeParseResult(const PublicSuffixParseResult &result) {
   }
 }
 
-Matcher matcher_from_serialization(const SerializedBuffer &buffer) {
+Matcher matcher_from_serialization(const SerializedBuffer& buffer) {
   SerializedChildBuffers child_buffers = internal::deserialize_buffer(buffer);
   return {
     internal::rule_set_from_serialization(child_buffers[0]),
diff --git a/etld/matcher.h b/etld/matcher.h
index 98e8dc1..48baaab 100644
--- a/etld/matcher.h
+++ b/etld/matcher.h
@@ -22,24 +22,24 @@ class Matcher {
  public:
   Matcher() {}
   Matcher(const Matcher &matcher);
-  explicit Matcher(std::ifstream &rule_file);
-  explicit Matcher(const std::string &rule_text);
-  explicit Matcher(const internal::PublicSuffixParseResult &rules);
-  Matcher(const internal::PublicSuffixRuleSet &rules,
-    const internal::PublicSuffixRuleSet &exception_rules);
-  
+  explicit Matcher(std::ifstream* rule_file);
+  explicit Matcher(const std::string& rule_text);
+  explicit Matcher(const internal::PublicSuffixParseResult& rules);
+  Matcher(const internal::PublicSuffixRuleSet& rules,
+    const internal::PublicSuffixRuleSet& exception_rules);
+
   SerializationResult Serialize() const;
 
-  bool Equal(const Matcher &matcher) const;
-  DomainInfo Match(const Domain &domain) const;
+  bool Equal(const Matcher& matcher) const;
+  DomainInfo Match(const Domain& domain) const;
 
  private:
-  void ConsumeParseResult(const internal::PublicSuffixParseResult &result);
+  void ConsumeParseResult(const internal::PublicSuffixParseResult& result);
   internal::PublicSuffixRuleSet rules_;
   internal::PublicSuffixRuleSet exception_rules_;
 };
 
-Matcher matcher_from_serialization(const SerializedBuffer &buffer);
+Matcher matcher_from_serialization(const SerializedBuffer& buffer);
 
 }  // namespace brave_etld
 
diff --git a/etld/serialization.cc b/etld/serialization.cc
index 2ef8b35..b9da579 100644
--- a/etld/serialization.cc
+++ b/etld/serialization.cc
@@ -3,34 +3,37 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#include <iostream>
+#include "etld/serialization.h"
 #include <vector>
 #include <string>
-#include "etld/serialization.h"
 
 namespace brave_etld {
 namespace internal {
 
-SerializedBufferInfo extract_buffer_info(const SerializedBuffer &buffer) {
-  SerializedBufferInfo info;
+SerializedBufferInfo extract_buffer_info(const SerializedBuffer& buffer) {
   const size_t splitter_pos = buffer.find(":");
   if (splitter_pos == std::string::npos) {
-    info.body_len = std::string::npos;
-    info.body_start = std::string::npos;
-    info.buffer_len = 0;
-    return info;
+    return {
+      std::string::npos,
+      std::string::npos,
+      0
+    };
   }
 
   const std::string header_str = buffer.substr(0, splitter_pos);
-  info.body_start = splitter_pos + 1;
-  info.body_len = std::stoi(header_str);
-  info.buffer_len = info.body_start + info.body_len;
-  return info;
+  const size_t body_len = std::stoi(header_str);
+  const size_t body_start = splitter_pos + 1;
+  const size_t buffer_len = body_start + body_len;
+  return {
+    body_len,
+    body_start,
+    buffer_len
+  };
 }
 
-SerializedChildBuffers deserialize_buffer(const SerializedBuffer &buffer) {
+SerializedChildBuffers deserialize_buffer(const SerializedBuffer& buffer) {
   std::vector<SerializedBuffer> child_buffers;
-  SerializedBufferInfo info = extract_buffer_info(buffer);
+  const SerializedBufferInfo info = extract_buffer_info(buffer);
   if (info.body_len == std::string::npos) {
     return child_buffers;
   }
@@ -39,10 +42,11 @@ SerializedChildBuffers deserialize_buffer(const SerializedBuffer &buffer) {
   size_t offset = info.body_start;
   std::string child_buffer;
   while (offset < payload_len) {
-    info = extract_buffer_info(buffer.substr(offset, payload_len - offset));
-    child_buffer = buffer.substr(offset, info.buffer_len);
+    const SerializedBufferInfo child_info = extract_buffer_info(
+      buffer.substr(offset, payload_len - offset));
+    child_buffer = buffer.substr(offset, child_info.buffer_len);
     child_buffers.push_back(child_buffer);
-    offset += info.buffer_len;
+    offset += child_info.buffer_len;
   }
 
   return child_buffers;
diff --git a/etld/serialization.h b/etld/serialization.h
index 2ec9ded..4ae8500 100644
--- a/etld/serialization.h
+++ b/etld/serialization.h
@@ -15,21 +15,21 @@ typedef std::string SerializedBuffer;
 
 struct SerializationResult {
   const SerializedBuffer buffer;
-  size_t body_start;
-  size_t body_len;
+  const size_t body_start;
+  const size_t body_len;
 };
 
 namespace internal {
 
 struct SerializedBufferInfo {
-  size_t body_len;
-  size_t body_start;
-  size_t buffer_len;
+  const size_t body_len;
+  const size_t body_start;
+  const size_t buffer_len;
 };
 
 typedef std::vector<SerializedBuffer> SerializedChildBuffers;
-SerializedBufferInfo extract_buffer_info(const SerializedBuffer &buffer);
-SerializedChildBuffers deserialize_buffer(const SerializedBuffer &buffer);
+SerializedBufferInfo extract_buffer_info(const SerializedBuffer& buffer);
+SerializedChildBuffers deserialize_buffer(const SerializedBuffer& buffer);
 
 }  // namespace internal
 }  // namespace brave_etld
diff --git a/test/etld_blocking_test.cc b/test/etld_blocking_test.cc
index 45c3474..fd9d531 100644
--- a/test/etld_blocking_test.cc
+++ b/test/etld_blocking_test.cc
@@ -247,4 +247,4 @@ TEST(etldSerializationTests, basic) {
     public_suffix_rules,
     third_party_rule,
     true));
-}
\ No newline at end of file
+}
diff --git a/test/etld_test.cc b/test/etld_test.cc
index 3795bc9..f2ec431 100644
--- a/test/etld_test.cc
+++ b/test/etld_test.cc
@@ -172,7 +172,7 @@ bool testParsePublicSuffixFileTest(
     int num_expected_invalid_lines) {
   std::ifstream rule_file;
   rule_file.open(file_path, std::ifstream::in);
-  PublicSuffixParseResult result = parse_rule_file(rule_file);
+  PublicSuffixParseResult result = parse_rule_file(&rule_file);
   return _verifyParsePublicSuffixTest(
     result,
     num_expected_rules,
@@ -288,7 +288,7 @@ bool testPublicSuffixRuleFileApply(const string &file_path,
     const string &domain_str, const DomainInfo &expected) {
   std::ifstream rule_file;
   rule_file.open(file_path, std::ifstream::in);
-  Matcher matcher(rule_file);
+  Matcher matcher(&rule_file);
   DomainInfo extracted = matcher.Match(Domain(domain_str));
 
   if (extracted.tld != expected.tld) {

From cd45c8361844d57cb1577f97f9795abe1202e0fa Mon Sep 17 00:00:00 2001
From: Peter Snyder <snyderp@gmail.com>
Date: Mon, 25 Feb 2019 21:09:09 -0800
Subject: [PATCH 09/13] fix memory leak during serialization

---
 etld/internal/public_suffix_rule.cc     |  5 ++++-
 etld/internal/public_suffix_rule_set.cc | 11 +++++++----
 etld/matcher.cc                         | 13 ++++++++-----
 3 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/etld/internal/public_suffix_rule.cc b/etld/internal/public_suffix_rule.cc
index e2c75e1..6d67617 100644
--- a/etld/internal/public_suffix_rule.cc
+++ b/etld/internal/public_suffix_rule.cc
@@ -121,8 +121,11 @@ SerializationResult PublicSuffixRule::Serialize() const {
     is_wildcard_ ? 't' : 'f',
     domain_string.c_str());
 
+  const std::string serialized_buffer(buffer);
+  free(buffer);
+
   return {
-    buffer,
+    serialized_buffer,
     body_start,
     body_len
   };
diff --git a/etld/internal/public_suffix_rule_set.cc b/etld/internal/public_suffix_rule_set.cc
index 95bafd9..446d826 100644
--- a/etld/internal/public_suffix_rule_set.cc
+++ b/etld/internal/public_suffix_rule_set.cc
@@ -61,12 +61,12 @@ bool PublicSuffixRuleSet::Equal(const PublicSuffixRuleSet& rule_set) const {
 }
 
 SerializationResult PublicSuffixRuleSet::Serialize() const {
-  std::stringstream serialized_buffer;
+  std::stringstream buffer_stream;
   for (auto &elm : rules_) {
-    serialized_buffer << elm->Serialize().buffer;
+    buffer_stream << elm->Serialize().buffer;
   }
 
-  const std::string buffer_body = serialized_buffer.str();
+  const std::string buffer_body = buffer_stream.str();
   const size_t body_len = buffer_body.size();
   const std::string header_str = std::to_string(body_len);
   const size_t header_len = header_str.size();
@@ -81,8 +81,11 @@ SerializationResult PublicSuffixRuleSet::Serialize() const {
     header_str.c_str(),
     buffer_body.c_str());
 
+  const std::string serialized_buffer(buffer);
+  free(buffer);
+
   return {
-    buffer,
+    serialized_buffer,
     body_start,
     body_len
   };
diff --git a/etld/matcher.cc b/etld/matcher.cc
index 010f1cc..c557654 100644
--- a/etld/matcher.cc
+++ b/etld/matcher.cc
@@ -45,11 +45,11 @@ Matcher::Matcher(const internal::PublicSuffixRuleSet& rules,
   exception_rules_(exception_rules) {}
 
 SerializationResult Matcher::Serialize() const {
-  std::stringstream serialized_buffer;
-  serialized_buffer << rules_.Serialize().buffer;
-  serialized_buffer << exception_rules_.Serialize().buffer;
+  std::stringstream buffer_stream;
+  buffer_stream << rules_.Serialize().buffer;
+  buffer_stream << exception_rules_.Serialize().buffer;
 
-  const std::string buffer_body = serialized_buffer.str();
+  const std::string buffer_body = buffer_stream.str();
   const size_t body_len = buffer_body.size();
   const std::string header_str = std::to_string(body_len);
   const size_t header_len = header_str.size();
@@ -64,8 +64,11 @@ SerializationResult Matcher::Serialize() const {
     header_str.c_str(),
     buffer_body.c_str());
 
+  const std::string serialized_buffer(buffer);
+  free(buffer);
+
   return {
-    buffer,
+    serialized_buffer,
     body_start,
     body_len
   };

From 1ef0dedbac4c03866e519185642313d4adade30b Mon Sep 17 00:00:00 2001
From: Peter Snyder <snyderp@gmail.com>
Date: Mon, 25 Feb 2019 21:45:17 -0800
Subject: [PATCH 10/13] Avoid some more possible stack allocations, const a
 bunch of more things

---
 etld/domain.cc                          |  2 +-
 etld/internal/parser.cc                 | 10 ++++------
 etld/internal/public_suffix_rule.cc     | 14 +++++++-------
 etld/internal/public_suffix_rule_set.cc |  2 +-
 etld/matcher.cc                         |  2 +-
 5 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/etld/domain.cc b/etld/domain.cc
index 7bc7bad..59b42ba 100644
--- a/etld/domain.cc
+++ b/etld/domain.cc
@@ -53,7 +53,7 @@ std::string Domain::ToString() const {
   std::stringstream as_string;
   const size_t num_labels = labels_.size();
   size_t i = 0;
-  for (auto &str : labels_) {
+  for (const auto &str : labels_) {
     as_string << str;
     if (i != num_labels - 1) {
       as_string << ".";
diff --git a/etld/internal/parser.cc b/etld/internal/parser.cc
index b54977f..450ba39 100644
--- a/etld/internal/parser.cc
+++ b/etld/internal/parser.cc
@@ -76,21 +76,19 @@ PublicSuffixParseResult parse_rule_text(const std::string& text) {
 PublicSuffixTextLineParseResult parse_rule_line(const std::string& line) {
   // Check to see if this is a comment line.  If so, process no further.
   if (line.find("//") == 0) {
-    return PublicSuffixTextLineParseResult(PublicSuffixTextLineTypeComment);
+    return {PublicSuffixTextLineTypeComment};
   }
 
   const size_t first_non_white_space_char = line.find_first_not_of(" ");
   // Next, check to see if the line is only whitespace.
   if (first_non_white_space_char == std::string::npos) {
-    return PublicSuffixTextLineParseResult(PublicSuffixTextLineTypeWhitespace);
+    return {PublicSuffixTextLineTypeWhitespace};
   }
 
   try {
-    return PublicSuffixTextLineParseResult(
-      PublicSuffixTextLineTypeRule,
-      new PublicSuffixRule(line));
+    return {PublicSuffixTextLineTypeRule, new PublicSuffixRule(line)};
   } catch (PublicSuffixRuleInputException error) {
-    return PublicSuffixTextLineParseResult(PublicSuffixTextLineTypeInvalidRule);
+    return {PublicSuffixTextLineTypeInvalidRule};
   }
 }
 
diff --git a/etld/internal/public_suffix_rule.cc b/etld/internal/public_suffix_rule.cc
index 6d67617..6e209cd 100644
--- a/etld/internal/public_suffix_rule.cc
+++ b/etld/internal/public_suffix_rule.cc
@@ -169,8 +169,8 @@ bool PublicSuffixRule::Matches(const Domain& domain) const {
 }
 
 DomainInfo PublicSuffixRule::Apply(const Domain& domain) const {
-  const auto domain_len = domain.Length();
-  auto rule_len = Length();
+  const size_t domain_len = domain.Length();
+  size_t rule_len = Length();
   if (IsException()) {
     rule_len -= 1;
   }
@@ -221,10 +221,10 @@ DomainInfo PublicSuffixRule::Apply(const Domain& domain) const {
 }
 
 std::string PublicSuffixRule::DomainString() const {
-  auto last_label_index = labels_.size() - 1;
+  const size_t last_label_index = labels_.size() - 1;
   size_t label_index = 0;
   std::stringstream as_string;
-  for (auto &elm : labels_) {
+  for (const auto &elm : labels_) {
     as_string << elm;
     if (label_index != last_label_index) {
       as_string << ".";
@@ -254,11 +254,11 @@ std::string PublicSuffixRule::ToString() const {
 PublicSuffixRule rule_from_serialization(const SerializedBuffer& buffer) {
   const SerializedBufferInfo info = extract_buffer_info(buffer);
   const std::string body_str = buffer.substr(info.body_start, info.body_len);
-  bool is_exception = body_str[0] == 't';
-  bool is_wildcard = body_str[1] == 't';
+  const bool is_exception = body_str[0] == 't';
+  const bool is_wildcard = body_str[1] == 't';
   const std::string label_str(body_str, 2, info.body_len - 2);
   const std::vector<Label> labels = parse_labels(label_str);
-  return PublicSuffixRule(labels, is_exception, is_wildcard);
+  return {labels, is_exception, is_wildcard};
 }
 
 }  // namespace internal
diff --git a/etld/internal/public_suffix_rule_set.cc b/etld/internal/public_suffix_rule_set.cc
index 446d826..819e693 100644
--- a/etld/internal/public_suffix_rule_set.cc
+++ b/etld/internal/public_suffix_rule_set.cc
@@ -180,7 +180,7 @@ void PublicSuffixRuleSet::AddRule(const PublicSuffixRule& rule,
 PublicSuffixRuleSet rule_set_from_serialization(
     const SerializedBuffer& buffer) {
   std::vector<PublicSuffixRule> rules;
-  for (auto &elm : deserialize_buffer(buffer)) {
+  for (const auto &elm : deserialize_buffer(buffer)) {
     rules.push_back(rule_from_serialization(elm));
   }
   return PublicSuffixRuleSet(rules);
diff --git a/etld/matcher.cc b/etld/matcher.cc
index c557654..0a15a37 100644
--- a/etld/matcher.cc
+++ b/etld/matcher.cc
@@ -96,7 +96,7 @@ DomainInfo Matcher::Match(const Domain& domain) const {
 }
 
 void Matcher::ConsumeParseResult(const PublicSuffixParseResult& result) {
-  for (auto &elm : result.Rules()) {
+  for (const auto &elm : result.Rules()) {
     if (elm.IsException()) {
       exception_rules_.AddRule(elm);
     } else {

From 4ce828ba7a0d1faa4948767bda8b3c6a914db5a7 Mon Sep 17 00:00:00 2001
From: Peter Snyder <snyderp@gmail.com>
Date: Thu, 28 Feb 2019 13:44:19 -0800
Subject: [PATCH 11/13] remove exceptions

---
 etld/domain.cc                          |  19 ++--
 etld/domain.h                           |  14 ++-
 etld/internal/parser.cc                 | 145 ++++++++++++++++++++----
 etld/internal/parser.h                  |  35 ++++--
 etld/internal/public_suffix_rule.cc     | 122 ++++++--------------
 etld/internal/public_suffix_rule.h      |  35 ++----
 etld/internal/public_suffix_rule_set.cc |  32 ++++--
 etld/internal/public_suffix_rule_set.h  |  26 ++---
 etld/matcher.cc                         |  27 +++--
 etld/matcher.h                          |  12 +-
 etld/serialization.cc                   |  16 +--
 etld/serialization.h                    |   7 +-
 etld/types.h                            |   8 +-
 test/etld_blocking_test.cc              |  56 ++++-----
 test/etld_serialization_test.cc         |   4 +-
 test/etld_test.cc                       |  38 +++----
 16 files changed, 337 insertions(+), 259 deletions(-)

diff --git a/etld/domain.cc b/etld/domain.cc
index 59b42ba..916a7dc 100644
--- a/etld/domain.cc
+++ b/etld/domain.cc
@@ -7,23 +7,24 @@
 #include <string>
 #include <sstream>
 
-namespace brave_etld {
+using ::std::string;
+using ::std::stringstream;
+using ::std::vector;
 
-Domain::Domain(const Domain& domain) :
-  labels_(domain.labels_) {}
+namespace brave_etld {
 
-Domain::Domain(const std::vector<Label>& labels) :
+Domain::Domain(const vector<Label>& labels) :
   labels_(labels) {}
 
-Domain::Domain(const std::string& string) {
+Domain::Domain(const string& string) {
   size_t current, previous = 0;
   current = string.find(".");
-  if (current == std::string::npos) {
+  if (current == string::npos) {
     labels_.push_back(string);
     return;
   }
 
-  while (current != std::string::npos) {
+  while (current != string::npos) {
     labels_.push_back(string.substr(previous, current - previous));
     previous = current + 1;
     current = string.find(".", previous);
@@ -49,8 +50,8 @@ bool Domain::Equals(const Domain& domain) {
   return true;
 }
 
-std::string Domain::ToString() const {
-  std::stringstream as_string;
+string Domain::ToString() const {
+  stringstream as_string;
   const size_t num_labels = labels_.size();
   size_t i = 0;
   for (const auto &str : labels_) {
diff --git a/etld/domain.h b/etld/domain.h
index 0d121ba..0e443e5 100644
--- a/etld/domain.h
+++ b/etld/domain.h
@@ -10,13 +10,17 @@
 #include <vector>
 #include "etld/types.h"
 
+using ::std::vector;
+using ::std::string;
+
 namespace brave_etld {
 
 class Domain {
  public:
-  explicit Domain(const Domain& domain);
-  explicit Domain(const std::string& domain);
-  explicit Domain(const std::vector<Label>& labels);
+  explicit Domain(const Domain& domain) = default;
+  explicit Domain(const vector<Label>& labels);
+  explicit Domain(const string& domain);
+  ~Domain() = default;
 
   bool Equals(const Domain &domain);
 
@@ -28,10 +32,10 @@ class Domain {
     return labels_[idx];
   }
 
-  std::string ToString() const;
+  string ToString() const;
 
  protected:
-  std::vector<Label> labels_;
+  vector<Label> labels_;
 };
 
 }  // namespace brave_etld
diff --git a/etld/internal/parser.cc b/etld/internal/parser.cc
index 450ba39..dcdd787 100644
--- a/etld/internal/parser.cc
+++ b/etld/internal/parser.cc
@@ -8,22 +8,39 @@
 #include <sstream>
 #include <fstream>
 #include <vector>
+#include <iostream>
 #include "etld/internal/public_suffix_rule.h"
 #include "etld/types.h"
 
+using ::std::ifstream;
+using ::std::istringstream;
+using ::std::string;
+using ::std::vector;
+
 namespace brave_etld {
 namespace internal {
 
-PublicSuffixParseResult::PublicSuffixParseResult() {}
+PublicSuffixTextLabelsParseResult::PublicSuffixTextLabelsParseResult(
+    const string error) : 
+      is_success(false),
+      error(error) {}
+
+PublicSuffixTextLabelsParseResult::PublicSuffixTextLabelsParseResult(
+  const vector<Label>& labels) :
+      is_success(true),
+      error(""),
+      labels(labels) {}
+
+PublicSuffixTextLineParseResult::PublicSuffixTextLineParseResult(
+  PublicSuffixTextLineType type, const PublicSuffixRule* rule,
+  const string error) :
+    type(type),
+    rule(rule),
+    error(error) {}
 
-PublicSuffixParseResult::PublicSuffixParseResult(
-    const PublicSuffixParseResult& results) :
-  num_whitespace_lines_(results.num_whitespace_lines_),
-  num_comment_lines_(results.num_comment_lines_),
-  num_invalid_rules_(results.num_invalid_rules_),
-  rules_(results.rules_) {}
+PublicSuffixParseResult::PublicSuffixParseResult() {}
 
-const std::vector<PublicSuffixRule>& PublicSuffixParseResult::Rules() const {
+const vector<PublicSuffixRule>& PublicSuffixParseResult::Rules() const {
   return rules_;
 }
 
@@ -52,28 +69,28 @@ void PublicSuffixParseResult::ConsumeParseResult(
   }
 }
 
-PublicSuffixParseResult parse_rule_file(std::ifstream* rule_file) {
-  std::string line;
+PublicSuffixParseResult parse_rule_file(ifstream* rule_file) {
+  string line;
   PublicSuffixParseResult results;
-  while (std::getline(*rule_file, line)) {
+  while (::std::getline(*rule_file, line)) {
     results.ConsumeParseResult(parse_rule_line(line));
   }
 
   return results;
 }
 
-PublicSuffixParseResult parse_rule_text(const std::string& text) {
-  std::istringstream stream(text);
-  std::string line;
+PublicSuffixParseResult parse_rule_text(const string& text) {
+  istringstream stream(text);
+  string line;
   PublicSuffixParseResult results;
-  while (std::getline(stream, line)) {
+  while (::std::getline(stream, line)) {
     results.ConsumeParseResult(parse_rule_line(line));
   }
 
   return results;
 }
 
-PublicSuffixTextLineParseResult parse_rule_line(const std::string& line) {
+PublicSuffixTextLineParseResult parse_rule_line(const string& line) {
   // Check to see if this is a comment line.  If so, process no further.
   if (line.find("//") == 0) {
     return {PublicSuffixTextLineTypeComment};
@@ -81,15 +98,101 @@ PublicSuffixTextLineParseResult parse_rule_line(const std::string& line) {
 
   const size_t first_non_white_space_char = line.find_first_not_of(" ");
   // Next, check to see if the line is only whitespace.
-  if (first_non_white_space_char == std::string::npos) {
+  if (first_non_white_space_char == string::npos) {
     return {PublicSuffixTextLineTypeWhitespace};
   }
 
-  try {
-    return {PublicSuffixTextLineTypeRule, new PublicSuffixRule(line)};
-  } catch (PublicSuffixRuleInputException error) {
-    return {PublicSuffixTextLineTypeInvalidRule};
+  string trimmed_rule_text(trim_to_whitespace(line));
+  if (trimmed_rule_text.length() == 0) {
+    return {
+      PublicSuffixTextLineTypeInvalidRule,
+      nullptr, 
+      "Cannot create PublicSuffixRule from an empty string"
+    };
+  }
+
+  bool is_wildcard = false;
+  bool is_exception = false;
+
+  size_t current = 0;
+  switch (trimmed_rule_text[0]) {
+    case '*':
+      is_wildcard = true;
+      break;
+
+    case '!':
+      is_exception = true;
+      current += 1;
+      break;
+
+    case '/':
+      return {
+        PublicSuffixTextLineTypeInvalidRule,
+        nullptr, 
+        "Rules cannot start with '/'"
+      };
+      break;
+
+    default:
+      break;
+  }
+
+  string labels_view(trimmed_rule_text, current);
+  const auto label_result(parse_labels(labels_view));
+  if (!label_result.is_success) {
+    return {
+      PublicSuffixTextLineTypeInvalidRule,
+      nullptr,
+      label_result.error
+    };
+  }
+
+  return {
+    PublicSuffixTextLineTypeRule,
+    new PublicSuffixRule(label_result.labels, is_exception, is_wildcard)
+  };
+}
+
+string trim_to_whitespace(string const& str) {
+  if (str.empty()) {
+    return str;
+  }
+
+  const size_t first_scan = str.find_first_of(' ');
+  if (first_scan == string::npos) {
+    return str;
   }
+
+  return str.substr(0, first_scan);
+}
+
+PublicSuffixTextLabelsParseResult parse_labels(const string& label_text) {
+  vector<Label> labels;
+  size_t previous = 0;
+  size_t current = label_text.find(".");
+  Label current_label;
+  while (current != string::npos) {
+    current_label = label_text.substr(previous, current - previous);
+    if (current_label.length() == 0) {
+      return {
+        "Rules cannot contain adjectent delimitors: " + label_text
+      };
+    }
+    labels.push_back(current_label);
+    previous = current + 1;
+    current = label_text.find(".", previous);
+  }
+
+  // If don't include any trailing whitespace, if there is any.
+  current_label = label_text.substr(previous, current - previous);
+  if (current_label == "") {
+    return {
+      "Rules cannot end with a delimiter: " + label_text
+    };
+  }
+
+  labels.push_back(current_label);
+  return {labels};
 }
 
 }  // namespace internal
diff --git a/etld/internal/parser.h b/etld/internal/parser.h
index f5a6280..07409eb 100644
--- a/etld/internal/parser.h
+++ b/etld/internal/parser.h
@@ -12,6 +12,10 @@
 #include "etld/internal/public_suffix_rule.h"
 #include "etld/types.h"
 
+using ::std::ifstream;
+using ::std::string;
+using ::std::vector;
+
 namespace brave_etld {
 namespace internal {
 
@@ -23,22 +27,31 @@ enum PublicSuffixTextLineType {
   PublicSuffixTextLineTypeRule,
 };
 
+struct PublicSuffixTextLabelsParseResult {
+  PublicSuffixTextLabelsParseResult(const string error = "");
+  PublicSuffixTextLabelsParseResult(const vector<Label>& labels);
+  const bool is_success = false;
+  const string error;
+  const vector<Label> labels;
+};
+
 struct PublicSuffixTextLineParseResult {
   PublicSuffixTextLineParseResult(
-      PublicSuffixTextLineType type = PublicSuffixTextLineTypeNone,
-      const PublicSuffixRule* rule = nullptr) :
-    type(type),
-    rule(rule) {}
+    PublicSuffixTextLineType type = PublicSuffixTextLineTypeNone,
+    const PublicSuffixRule* rule = nullptr,
+    const string error = "");
   const PublicSuffixTextLineType type;
   const PublicSuffixRule* rule;
+  const string error;
 };
 
 class PublicSuffixParseResult {
  public:
   PublicSuffixParseResult();
-  PublicSuffixParseResult(const PublicSuffixParseResult& results);
+  PublicSuffixParseResult(const PublicSuffixParseResult& results) = default;
+  ~PublicSuffixParseResult() = default;
 
-  const std::vector<PublicSuffixRule>& Rules() const;
+  const vector<PublicSuffixRule>& Rules() const;
   void ConsumeParseResult(const PublicSuffixTextLineParseResult& result);
 
   int NumWhitespaceLines() const {
@@ -57,14 +70,16 @@ class PublicSuffixParseResult {
   int num_whitespace_lines_ = 0;
   int num_comment_lines_ = 0;
   int num_invalid_rules_ = 0;
-  std::vector<PublicSuffixRule> rules_;
+  vector<PublicSuffixRule> rules_;
 };
 
 // This attempts to implement the algorithm described here:
 //   https://www.publicsuffix.org/list/
-PublicSuffixParseResult parse_rule_file(std::ifstream* rule_file);
-PublicSuffixParseResult parse_rule_text(const std::string& rule_text);
-PublicSuffixTextLineParseResult parse_rule_line(const std::string& line);
+PublicSuffixParseResult parse_rule_file(ifstream* rule_file);
+PublicSuffixParseResult parse_rule_text(const string& rule_text);
+PublicSuffixTextLineParseResult parse_rule_line(const string& line);
+string trim_to_whitespace(const string &rule_text);
+PublicSuffixTextLabelsParseResult parse_labels(const string& label_text);
 
 }  // namespace internal
 }  // namespace brave_etld
diff --git a/etld/internal/public_suffix_rule.cc b/etld/internal/public_suffix_rule.cc
index 6e209cd..5a8392e 100644
--- a/etld/internal/public_suffix_rule.cc
+++ b/etld/internal/public_suffix_rule.cc
@@ -8,95 +8,37 @@
 #include <sstream>
 #include <vector>
 #include <cstdio>
+#include <iostream>
+#include "etld/internal/parser.h"
 #include "etld/domain.h"
 #include "etld/types.h"
 #include "etld/serialization.h"
 
+using ::std::string;
+using ::std::stringstream;
+using ::std::vector;
+
 namespace brave_etld {
 namespace internal {
 
-const PublicSuffixRule* PublicSuffixRule::root_rule = new PublicSuffixRule("*");
-
-std::vector<Label> parse_labels(const std::string& label_text) {
-  std::vector<Label> labels;
-  size_t previous = 0;
-  size_t current = label_text.find(".");
-  Label current_label;
-  while (current != std::string::npos) {
-    current_label = label_text.substr(previous, current - previous);
-    if (current_label.length() == 0) {
-      throw PublicSuffixRuleInputException(
-        "Rules cannot contain adjectent delimitors: " + label_text);
-    }
-    labels.push_back(current_label);
-    previous = current + 1;
-    current = label_text.find(".", previous);
-  }
-
-  // If don't include any trailing whitespace, if there is any.
-  current_label = label_text.substr(previous, current - previous);
-  if (current_label == "") {
-    throw PublicSuffixRuleInputException(
-      "Rules cannot end with a delimiter: " + label_text);
-  }
-
-  labels.push_back(current_label);
-  return labels;
-}
-
-// Cargo-cult-ed from https://codereview.stackexchange.com/questions/40124/trim-white-space-from-string
-std::string trim_to_whitespace(std::string const& str) {
-  if (str.empty()) {
-    return str;
-  }
-
-  const size_t first_scan = str.find_first_of(' ');
-  if (first_scan == std::string::npos) {
-    return str;
-  }
-
-  return str.substr(0, first_scan);
-}
-
 PublicSuffixRule::PublicSuffixRule() {}
 
-PublicSuffixRule::PublicSuffixRule(const PublicSuffixRule& rule) :
-  labels_(rule.labels_),
-  is_exception_(rule.IsException()),
-  is_wildcard_(rule.IsWildcard()) {}
-
-PublicSuffixRule::PublicSuffixRule(const std::string& rule_text) {
-  std::string trimmed_rule_text(trim_to_whitespace(rule_text));
-  if (trimmed_rule_text.length() == 0) {
-    throw PublicSuffixRuleInputException(
-      "Cannot create PublicSuffixRule from an empty string");
-  }
-
-  size_t current = 0;
-  switch (trimmed_rule_text[0]) {
-    case '*':
-      is_wildcard_ = true;
-      break;
-
-    case '!':
-      is_exception_ = true;
-      current += 1;
-      break;
-
-    case '/':
-      throw PublicSuffixRuleInputException(
-        "Rules cannot start with '/': " + rule_text);
-      break;
-
-    default:
-      break;
+PublicSuffixRule::PublicSuffixRule(const string& rule_text) {
+  PublicSuffixTextLineParseResult parse_result = parse_rule_line(rule_text);
+  // This will only ever be hit in tests, since external code should never
+  // initialize rules directly, and this initializer receiving
+  // bad rules is guarded by code in the parser.
+  if (parse_result.type != PublicSuffixTextLineTypeRule) {
+    PublicSuffixRule();
+    return;
   }
 
-  std::string labels_view(trimmed_rule_text, current);
-  labels_ = parse_labels(labels_view);
+  is_wildcard_ = parse_result.rule->is_wildcard_;
+  is_exception_ = parse_result.rule->is_exception_;
+  labels_ = parse_result.rule->labels_;
 }
 
-PublicSuffixRule::PublicSuffixRule(const std::vector<Label>& labels,
+PublicSuffixRule::PublicSuffixRule(const vector<Label>& labels,
   bool is_exception, bool is_wildcard) :
     labels_(labels),
     is_exception_(is_exception),
@@ -104,9 +46,9 @@ PublicSuffixRule::PublicSuffixRule(const std::vector<Label>& labels,
 }
 
 SerializationResult PublicSuffixRule::Serialize() const {
-  const std::string domain_string = DomainString();
+  const string domain_string = DomainString();
   const size_t body_len = domain_string.size() + 2;
-  const std::string header_str = std::to_string(body_len);
+  const string header_str = ::std::to_string(body_len);
   const size_t header_len = header_str.size();
   const size_t body_start = header_len + 1;
   const uint buffer_size = body_start + body_len + 1;
@@ -121,7 +63,7 @@ SerializationResult PublicSuffixRule::Serialize() const {
     is_wildcard_ ? 't' : 'f',
     domain_string.c_str());
 
-  const std::string serialized_buffer(buffer);
+  const string serialized_buffer(buffer);
   free(buffer);
 
   return {
@@ -176,13 +118,13 @@ DomainInfo PublicSuffixRule::Apply(const Domain& domain) const {
   }
 
   auto tld_seg_len = rule_len;
-  std::stringstream tld_seg;
+  stringstream tld_seg;
 
   auto domain_seg_len = (tld_seg_len == domain_len) ? 0 : 1;
-  std::stringstream domain_seg;
+  stringstream domain_seg;
 
   auto sub_domain_seg_len = domain_len - domain_seg_len - tld_seg_len;
-  std::stringstream sub_domain_seg;
+  stringstream sub_domain_seg;
 
   Label domain_label;
   for (size_t i = 0; i < domain_len; i += 1) {
@@ -220,10 +162,10 @@ DomainInfo PublicSuffixRule::Apply(const Domain& domain) const {
   };
 }
 
-std::string PublicSuffixRule::DomainString() const {
+string PublicSuffixRule::DomainString() const {
   const size_t last_label_index = labels_.size() - 1;
   size_t label_index = 0;
-  std::stringstream as_string;
+  stringstream as_string;
   for (const auto &elm : labels_) {
     as_string << elm;
     if (label_index != last_label_index) {
@@ -243,8 +185,8 @@ size_t PublicSuffixRule::Length() const {
   return labels_.size();
 }
 
-std::string PublicSuffixRule::ToString() const {
-  std::stringstream as_string;
+string PublicSuffixRule::ToString() const {
+  stringstream as_string;
   as_string << "labels: [" << DomainString() << "] ";
   as_string << "is exception: " << (is_exception_ ? "true" : "false") << " ";
   as_string << "is wildcard: " << (is_wildcard_ ? "true" : "false");
@@ -253,12 +195,12 @@ std::string PublicSuffixRule::ToString() const {
 
 PublicSuffixRule rule_from_serialization(const SerializedBuffer& buffer) {
   const SerializedBufferInfo info = extract_buffer_info(buffer);
-  const std::string body_str = buffer.substr(info.body_start, info.body_len);
+  const string body_str = buffer.substr(info.body_start, info.body_len);
   const bool is_exception = body_str[0] == 't';
   const bool is_wildcard = body_str[1] == 't';
-  const std::string label_str(body_str, 2, info.body_len - 2);
-  const std::vector<Label> labels = parse_labels(label_str);
-  return {labels, is_exception, is_wildcard};
+  const string label_str(body_str, 2, info.body_len - 2);
+  const auto label_result = parse_labels(label_str);
+  return {label_result.labels, is_exception, is_wildcard};
 }
 
 }  // namespace internal
diff --git a/etld/internal/public_suffix_rule.h b/etld/internal/public_suffix_rule.h
index 262dc12..b7a990d 100644
--- a/etld/internal/public_suffix_rule.h
+++ b/etld/internal/public_suffix_rule.h
@@ -12,44 +12,32 @@
 #include "etld/types.h"
 #include "etld/serialization.h"
 
+using ::std::string;
+using ::std::vector;
+
 namespace brave_etld {
 namespace internal {
 
-class PublicSuffixRuleInputException : public std::exception {
- public:
-  explicit PublicSuffixRuleInputException(const char* message) :
-    msg_(message) {}
-  explicit PublicSuffixRuleInputException(const std::string &message) :
-    msg_(message) {}
-  virtual const char* what() const throw() {
-    return msg_.c_str();
-  }
-  virtual ~PublicSuffixRuleInputException() throw() {}
-
- protected:
-  std::string msg_;
-};
-
 class PublicSuffixRule {
  public:
-  static const PublicSuffixRule* root_rule;
   PublicSuffixRule();
-  PublicSuffixRule(const PublicSuffixRule& rule);
-  explicit PublicSuffixRule(const std::string& rule_text);
+  explicit PublicSuffixRule(const string& rule_text);
   PublicSuffixRule(
-    const std::vector<Label>& labels,
+    const vector<Label>& labels,
     bool is_exception = false,
     bool is_wildcard = false);
+  PublicSuffixRule(const PublicSuffixRule& rule) = default;
+  ~PublicSuffixRule() = default;
 
   SerializationResult Serialize() const;
 
   bool Equals(const PublicSuffixRule& rule) const;
   bool Matches(const Domain& domain) const;
   DomainInfo Apply(const Domain& domain) const;
-  std::string ToString() const;
-  std::string DomainString() const;
+  string ToString() const;
+  string DomainString() const;
 
-  const std::vector<Label>& Labels() const;
+  const vector<Label>& Labels() const;
   size_t Length() const;
   const Label& Get(size_t idx) const {
     return labels_[idx];
@@ -63,13 +51,12 @@ class PublicSuffixRule {
   }
 
  protected:
-  std::vector<Label> labels_;
+  vector<Label> labels_;
   bool is_exception_ = false;
   bool is_wildcard_ = false;
 };
 
 PublicSuffixRule rule_from_serialization(const SerializedBuffer& buffer);
-std::vector<Label> parse_labels(const std::string& label_text);
 
 }  // namespace internal
 }  // namespace brave_etld
diff --git a/etld/internal/public_suffix_rule_set.cc b/etld/internal/public_suffix_rule_set.cc
index 819e693..bdfb052 100644
--- a/etld/internal/public_suffix_rule_set.cc
+++ b/etld/internal/public_suffix_rule_set.cc
@@ -3,22 +3,38 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+#include "etld/internal/public_suffix_rule_set.h"
 #include <string>
 #include <sstream>
 #include <vector>
 #include <map>
-#include <iostream>
 #include "etld/internal/public_suffix_rule.h"
-#include "etld/internal/public_suffix_rule_set.h"
 #include "etld/domain.h"
 #include "etld/types.h"
 #include "etld/serialization.h"
 
+using ::std::stringstream;
+using ::std::vector;
+using ::std::map;
+using ::std::string;
 using brave_etld::internal::PublicSuffixRuleSetMatchResult;
 
 namespace brave_etld {
 namespace internal {
 
+PublicSuffixRuleMapNode::PublicSuffixRuleMapNode() {
+  children = new map<string, PublicSuffixRuleMapNode*>();
+}
+
+PublicSuffixRuleMapNode::~PublicSuffixRuleMapNode() {
+  for (auto &elm : *children) {
+    delete elm.second;
+  }
+  if (rule != nullptr) {
+    delete rule;
+  }
+}
+
 PublicSuffixRuleSet::PublicSuffixRuleSet() {}
 
 PublicSuffixRuleSet::PublicSuffixRuleSet(const PublicSuffixRuleSet& rule_set) {
@@ -28,7 +44,7 @@ PublicSuffixRuleSet::PublicSuffixRuleSet(const PublicSuffixRuleSet& rule_set) {
 }
 
 PublicSuffixRuleSet::PublicSuffixRuleSet(
-    const std::vector<PublicSuffixRule>& rules) {
+    const vector<PublicSuffixRule>& rules) {
   for (auto &elm : rules) {
     AddRule(elm);
   }
@@ -61,14 +77,14 @@ bool PublicSuffixRuleSet::Equal(const PublicSuffixRuleSet& rule_set) const {
 }
 
 SerializationResult PublicSuffixRuleSet::Serialize() const {
-  std::stringstream buffer_stream;
+  stringstream buffer_stream;
   for (auto &elm : rules_) {
     buffer_stream << elm->Serialize().buffer;
   }
 
-  const std::string buffer_body = buffer_stream.str();
+  const string buffer_body = buffer_stream.str();
   const size_t body_len = buffer_body.size();
-  const std::string header_str = std::to_string(body_len);
+  const string header_str = ::std::to_string(body_len);
   const size_t header_len = header_str.size();
   const size_t body_start = header_len + 1;
   const size_t buffer_size = body_start + body_len + 1;
@@ -81,7 +97,7 @@ SerializationResult PublicSuffixRuleSet::Serialize() const {
     header_str.c_str(),
     buffer_body.c_str());
 
-  const std::string serialized_buffer(buffer);
+  const string serialized_buffer(buffer);
   free(buffer);
 
   return {
@@ -179,7 +195,7 @@ void PublicSuffixRuleSet::AddRule(const PublicSuffixRule& rule,
 
 PublicSuffixRuleSet rule_set_from_serialization(
     const SerializedBuffer& buffer) {
-  std::vector<PublicSuffixRule> rules;
+  vector<PublicSuffixRule> rules;
   for (const auto &elm : deserialize_buffer(buffer)) {
     rules.push_back(rule_from_serialization(elm));
   }
diff --git a/etld/internal/public_suffix_rule_set.h b/etld/internal/public_suffix_rule_set.h
index 7e7d630..ebf3542 100644
--- a/etld/internal/public_suffix_rule_set.h
+++ b/etld/internal/public_suffix_rule_set.h
@@ -6,13 +6,16 @@
 #ifndef ETLD_INTERNAL_PUBLIC_SUFFIX_RULE_SET_H_
 #define ETLD_INTERNAL_PUBLIC_SUFFIX_RULE_SET_H_
 
-#include "etld/internal/public_suffix_rule.h"
 #include <string>
 #include <vector>
 #include <map>
 #include "etld/domain.h"
 #include "etld/types.h"
 #include "etld/serialization.h"
+#include "etld/internal/public_suffix_rule.h"
+
+using ::std::vector;
+using ::std::map;
 
 namespace brave_etld {
 namespace internal {
@@ -23,27 +26,18 @@ struct PublicSuffixRuleSetMatchResult {
 };
 
 struct PublicSuffixRuleMapNode {
-  PublicSuffixRuleMapNode() {
-    children = new std::map<std::string, PublicSuffixRuleMapNode*>();
-  }
-  ~PublicSuffixRuleMapNode() {
-    for (auto &elm : *children) {
-      delete elm.second;
-    }
-    if (rule != nullptr) {
-      delete rule;
-    }
-  }
+  PublicSuffixRuleMapNode();
+  ~PublicSuffixRuleMapNode();
   const PublicSuffixRule* rule = nullptr;
-  std::map<std::string, PublicSuffixRuleMapNode*>* children = nullptr;
+  map<string, PublicSuffixRuleMapNode*>* children = nullptr;
 };
 
 class PublicSuffixRuleSet {
  public:
   PublicSuffixRuleSet();
-  ~PublicSuffixRuleSet();
-  explicit PublicSuffixRuleSet(const std::vector<PublicSuffixRule>& rules);
+  explicit PublicSuffixRuleSet(const vector<PublicSuffixRule>& rules);
   PublicSuffixRuleSet(const PublicSuffixRuleSet& rule_set);
+  ~PublicSuffixRuleSet();
 
   SerializationResult Serialize() const;
   bool Equal(const PublicSuffixRuleSet& rule_set) const;
@@ -57,7 +51,7 @@ class PublicSuffixRuleSet {
       const PublicSuffixRule** match, PublicSuffixRuleMapNode* node) const;
 
   PublicSuffixRuleMapNode* root_ = nullptr;
-  std::vector<PublicSuffixRule*> rules_;
+  vector<PublicSuffixRule*> rules_;
 };
 
 PublicSuffixRuleSet rule_set_from_serialization(const SerializedBuffer &buffer);
diff --git a/etld/matcher.cc b/etld/matcher.cc
index 0a15a37..81a242e 100644
--- a/etld/matcher.cc
+++ b/etld/matcher.cc
@@ -12,22 +12,33 @@
 #include "etld/internal/public_suffix_rule.h"
 #include "etld/serialization.h"
 
+using ::std::ifstream;
+using ::std::string;
+using ::std::stringstream;
+
+using brave_etld::internal::PublicSuffixRule;
 using brave_etld::internal::PublicSuffixParseResult;
 using brave_etld::internal::PublicSuffixRuleSetMatchResult;
 using brave_etld::internal::SerializedChildBuffers;
 
 namespace brave_etld {
 
+namespace {
+const PublicSuffixRule* ROOT_RULE = new PublicSuffixRule("*");
+}  // namespace
+
 DomainInfo build_domain_info(const internal::PublicSuffixRule* rule,
   const Domain& domain) {
   return rule->Apply(domain);
 }
 
-Matcher::Matcher(std::ifstream* rule_file) {
+Matcher::Matcher() {}
+
+Matcher::Matcher(ifstream* rule_file) {
   ConsumeParseResult(internal::parse_rule_file(rule_file));
 }
 
-Matcher::Matcher(const std::string& rule_text) {
+Matcher::Matcher(const string& rule_text) {
   ConsumeParseResult(internal::parse_rule_text(rule_text));
 }
 
@@ -35,23 +46,19 @@ Matcher::Matcher(const PublicSuffixParseResult& rules) {
   ConsumeParseResult(rules);
 }
 
-Matcher::Matcher(const Matcher& matcher) :
-  rules_(matcher.rules_),
-  exception_rules_(matcher.exception_rules_) {}
-
 Matcher::Matcher(const internal::PublicSuffixRuleSet& rules,
     const internal::PublicSuffixRuleSet& exception_rules) :
   rules_(rules),
   exception_rules_(exception_rules) {}
 
 SerializationResult Matcher::Serialize() const {
-  std::stringstream buffer_stream;
+  stringstream buffer_stream;
   buffer_stream << rules_.Serialize().buffer;
   buffer_stream << exception_rules_.Serialize().buffer;
 
-  const std::string buffer_body = buffer_stream.str();
+  const string buffer_body = buffer_stream.str();
   const size_t body_len = buffer_body.size();
-  const std::string header_str = std::to_string(body_len);
+  const string header_str = ::std::to_string(body_len);
   const size_t header_len = header_str.size();
   const size_t body_start = header_len + 1;
   const size_t buffer_size = body_start + body_len + 1;
@@ -92,7 +99,7 @@ DomainInfo Matcher::Match(const Domain& domain) const {
     return build_domain_info(rule_match.rule, domain);
   }
 
-  return build_domain_info(internal::PublicSuffixRule::root_rule, domain);
+  return build_domain_info(ROOT_RULE, domain);
 }
 
 void Matcher::ConsumeParseResult(const PublicSuffixParseResult& result) {
diff --git a/etld/matcher.h b/etld/matcher.h
index 48baaab..d818bcc 100644
--- a/etld/matcher.h
+++ b/etld/matcher.h
@@ -16,17 +16,21 @@
 #include "etld/internal/public_suffix_rule_set.h"
 #include "etld/serialization.h"
 
+using ::std::ifstream;
+using ::std::string;
+
 namespace brave_etld {
 
 class Matcher {
  public:
-  Matcher() {}
-  Matcher(const Matcher &matcher);
-  explicit Matcher(std::ifstream* rule_file);
-  explicit Matcher(const std::string& rule_text);
+  Matcher();
+  Matcher(const Matcher &matcher) = default;
+  explicit Matcher(ifstream* rule_file);
+  explicit Matcher(const string& rule_text);
   explicit Matcher(const internal::PublicSuffixParseResult& rules);
   Matcher(const internal::PublicSuffixRuleSet& rules,
     const internal::PublicSuffixRuleSet& exception_rules);
+  ~Matcher() = default;
 
   SerializationResult Serialize() const;
 
diff --git a/etld/serialization.cc b/etld/serialization.cc
index b9da579..34b5f80 100644
--- a/etld/serialization.cc
+++ b/etld/serialization.cc
@@ -7,21 +7,23 @@
 #include <vector>
 #include <string>
 
+using ::std::string;
+
 namespace brave_etld {
 namespace internal {
 
 SerializedBufferInfo extract_buffer_info(const SerializedBuffer& buffer) {
   const size_t splitter_pos = buffer.find(":");
-  if (splitter_pos == std::string::npos) {
+  if (splitter_pos == string::npos) {
     return {
-      std::string::npos,
-      std::string::npos,
+      string::npos,
+      string::npos,
       0
     };
   }
 
-  const std::string header_str = buffer.substr(0, splitter_pos);
-  const size_t body_len = std::stoi(header_str);
+  const string header_str = buffer.substr(0, splitter_pos);
+  const size_t body_len = ::std::stoi(header_str);
   const size_t body_start = splitter_pos + 1;
   const size_t buffer_len = body_start + body_len;
   return {
@@ -34,13 +36,13 @@ SerializedBufferInfo extract_buffer_info(const SerializedBuffer& buffer) {
 SerializedChildBuffers deserialize_buffer(const SerializedBuffer& buffer) {
   std::vector<SerializedBuffer> child_buffers;
   const SerializedBufferInfo info = extract_buffer_info(buffer);
-  if (info.body_len == std::string::npos) {
+  if (info.body_len == string::npos) {
     return child_buffers;
   }
 
   const size_t payload_len = buffer.size();
   size_t offset = info.body_start;
-  std::string child_buffer;
+  string child_buffer;
   while (offset < payload_len) {
     const SerializedBufferInfo child_info = extract_buffer_info(
       buffer.substr(offset, payload_len - offset));
diff --git a/etld/serialization.h b/etld/serialization.h
index 4ae8500..2ed0a8a 100644
--- a/etld/serialization.h
+++ b/etld/serialization.h
@@ -9,9 +9,12 @@
 #include <string>
 #include <vector>
 
+using ::std::string;
+using ::std::vector;
+
 namespace brave_etld {
 
-typedef std::string SerializedBuffer;
+typedef string SerializedBuffer;
 
 struct SerializationResult {
   const SerializedBuffer buffer;
@@ -27,7 +30,7 @@ struct SerializedBufferInfo {
   const size_t buffer_len;
 };
 
-typedef std::vector<SerializedBuffer> SerializedChildBuffers;
+typedef vector<SerializedBuffer> SerializedChildBuffers;
 SerializedBufferInfo extract_buffer_info(const SerializedBuffer& buffer);
 SerializedChildBuffers deserialize_buffer(const SerializedBuffer& buffer);
 
diff --git a/etld/types.h b/etld/types.h
index e19025f..c9c7e6c 100644
--- a/etld/types.h
+++ b/etld/types.h
@@ -12,12 +12,12 @@
 namespace brave_etld {
 
 struct DomainInfo {
-  const std::string tld;
-  const std::string domain;
-  const std::string subdomain;
+  const ::std::string tld;
+  const ::std::string domain;
+  const ::std::string subdomain;
 };
 
-typedef std::string Label;
+typedef ::std::string Label;
 
 }  // namespace brave_etld
 
diff --git a/test/etld_blocking_test.cc b/test/etld_blocking_test.cc
index fd9d531..f6beef6 100644
--- a/test/etld_blocking_test.cc
+++ b/test/etld_blocking_test.cc
@@ -12,7 +12,9 @@
 #include "./CppUnitLite/Test.h"
 #include "./ad_block_client.h"
 
-using std::string;
+using ::std::cout;
+using ::std::endl;
+using ::std::string;
 
 bool testThirdPartyBlockingWithRulesDomainAndPublixSuffixList(
     const string &rules, const string &url, const string &domain,
@@ -31,9 +33,9 @@ bool testThirdPartyBlockingWithRulesDomainAndPublixSuffixList(
     domain.c_str(), &matching_ptr, &exception_ptr);
 
   if (is_match != should_match) {
-    std::cout << "Expected " << (should_match ? "a match" : "no match")
-              << " but received " << (is_match ? "a match" : "no match")
-              << "." << std::endl;
+    cout << "Expected " << (should_match ? "a match" : "no match")
+         << " but received " << (is_match ? "a match" : "no match")
+         << "." << endl;
     return false;
   }
 
@@ -48,16 +50,16 @@ bool testThirdPartyBlockingWithRulesDomainAndPublixSuffixList(
     return true;
   }
 
-  std::cout << "Did not return the expected matching rule.  Expected '"
-            << expected_rule << "' but received '"
-            << matching_ptr->ruleDefinition << "'" << std::endl;
+  cout << "Did not return the expected matching rule.  Expected '"
+       << expected_rule << "' but received '"
+       << matching_ptr->ruleDefinition << "'" << endl;
   return false;
 }
 
 TEST(etldBlockingTests, basic) {
-  std::ifstream ifs("./test/data/public_suffix_list.dat");
-  const string public_suffix_rules((std::istreambuf_iterator<char>(ifs)),
-                                   (std::istreambuf_iterator<char>()));
+  ::std::ifstream ifs("./test/data/public_suffix_list.dat");
+  const string public_suffix_rules((::std::istreambuf_iterator<char>(ifs)),
+                                   (::std::istreambuf_iterator<char>()));
   const string third_party_rule = "||s3.amazonaws.com^$third-party";
   const string test_url = "http://www.spark-public.s3.amazonaws.com/ads.txt";
 
@@ -132,9 +134,9 @@ bool testAdBlockSerializationWithPublicSuffixList(const string &rules,
 
   // First make sure the first client behaves as expected.
   if (one_match != should_match) {
-    std::cout << "Expected " << (should_match ? "a match" : "no match")
-              << " with the first client, but received "
-              << (one_match ? "a match" : "no match") << "." << std::endl;
+    cout << "Expected " << (should_match ? "a match" : "no match")
+         << " with the first client, but received "
+         << (one_match ? "a match" : "no match") << "." << endl;
     return false;
   }
 
@@ -142,9 +144,9 @@ bool testAdBlockSerializationWithPublicSuffixList(const string &rules,
     bool is_expected_rule = strcmp(
       matching_ptr->ruleDefinition, expected_rule.c_str()) == 0;
     if (!is_expected_rule) {
-      std::cout << "Client one did not return the expected matching rule. "
-                << " Expected '" << expected_rule << "' but received '"
-                << matching_ptr->ruleDefinition << "'" << std::endl;
+      cout << "Client one did not return the expected matching rule. "
+           << " Expected '" << expected_rule << "' but received '"
+           << matching_ptr->ruleDefinition << "'" << endl;
       return false;
     }
   }
@@ -166,9 +168,9 @@ bool testAdBlockSerializationWithPublicSuffixList(const string &rules,
     domain.c_str(), &matching_ptr2, &exception_ptr2);
 
   if (one_match != two_match) {
-    std::cout << "Client one matched the filter correctly, but client two "
-              << "returned " << (two_match ? "a match" : "no match")
-              << ". " << std::endl;
+    cout << "Client one matched the filter correctly, but client two "
+         << "returned " << (two_match ? "a match" : "no match")
+         << ". " << endl;
     return false;
   }
 
@@ -176,11 +178,11 @@ bool testAdBlockSerializationWithPublicSuffixList(const string &rules,
     bool returned_rules_match = strncmp(matching_ptr->data,
       matching_ptr2->data, matching_ptr->dataLen) == 0;
     if (!returned_rules_match) {
-      std::cout << "Client two returned differnet rule data ("
-                << string(matching_ptr2->data, matching_ptr2->dataLen)
-                << ") from client one ("
-                << string(matching_ptr->data, matching_ptr->dataLen)
-                << ")." << std::endl;
+      cout << "Client two returned differnet rule data ("
+           << string(matching_ptr2->data, matching_ptr2->dataLen)
+           << ") from client one ("
+           << string(matching_ptr->data, matching_ptr->dataLen)
+           << ")." << endl;
       return false;
     }
   }
@@ -189,9 +191,9 @@ bool testAdBlockSerializationWithPublicSuffixList(const string &rules,
 }
 
 TEST(etldSerializationTests, basic) {
-  std::ifstream ifs("./test/data/public_suffix_list.dat");
-  const string public_suffix_rules((std::istreambuf_iterator<char>(ifs)),
-                                   (std::istreambuf_iterator<char>()));
+  ::std::ifstream ifs("./test/data/public_suffix_list.dat");
+  const string public_suffix_rules((::std::istreambuf_iterator<char>(ifs)),
+                                   (::std::istreambuf_iterator<char>()));
   const string third_party_rule = "||s3.amazonaws.com^$third-party";
   const string test_url = "http://www.spark-public.s3.amazonaws.com/ads.txt";
 
diff --git a/test/etld_serialization_test.cc b/test/etld_serialization_test.cc
index 17c9c43..a5c93f3 100644
--- a/test/etld_serialization_test.cc
+++ b/test/etld_serialization_test.cc
@@ -19,8 +19,8 @@
 #include "./etld/domain.h"
 #include "./etld/serialization.h"
 
-using std::string;
-using std::vector;
+using ::std::string;
+using ::std::vector;
 using brave_etld::internal::PublicSuffixRule;
 using brave_etld::internal::PublicSuffixRuleSet;
 using brave_etld::internal::rule_from_serialization;
diff --git a/test/etld_test.cc b/test/etld_test.cc
index f2ec431..d3f2f0c 100644
--- a/test/etld_test.cc
+++ b/test/etld_test.cc
@@ -17,13 +17,12 @@
 #include "./etld/matcher.h"
 #include "./etld/domain.h"
 
-using std::string;
-using std::cout;
-using std::endl;
+using ::std::string;
+using ::std::cout;
+using ::std::endl;
 
 using brave_etld::internal::PublicSuffixTextLineType;
 using brave_etld::internal::PublicSuffixTextLineParseResult;
-using brave_etld::internal::PublicSuffixRuleInputException;
 using brave_etld::internal::PublicSuffixRuleSetMatchResult;
 using brave_etld::internal::PublicSuffixRule;
 using brave_etld::internal::PublicSuffixRuleSet;
@@ -48,24 +47,23 @@ bool testParsePublicSuffixTestLineNoOps(const string &line,
 
 bool testParsePublicSuffixTestLineError(const string &line,
     const string &expected_error) {
-  try {
-    PublicSuffixRule rule(line);
-  } catch (PublicSuffixRuleInputException error) {
-    string error_string(error.what());
-    size_t error_substr_pos = error_string.find_first_of(expected_error);
-    if (error_substr_pos == string::npos) {
-      cout << "Caught an unexpected error when parsing " << line << "\n"
-           << "Expected '" << expected_error << "'\n"
-           << "Received '" << error.what() << endl;
-      return false;
-    }
-    return true;
+  PublicSuffixTextLineParseResult result = parse_rule_line(line);
+  if (result.type !=
+      PublicSuffixTextLineType::PublicSuffixTextLineTypeInvalidRule) {
+    cout << "Expected to receive an error when attempting to parse "
+         << "invalid rule '" << line << "' but no error was thrown." << endl;
+    return false;
   }
 
-  cout << "Expected to receive an error when attempting to parse invalid rule '"
-       << line
-       << "' but no error was thrown." << endl;
-  return false;
+  const size_t error_substr_pos = result.error.find_first_of(expected_error);
+  if (error_substr_pos == string::npos) {
+    cout << "Caught an unexpected error when parsing " << line << "\n"
+          << "Expected '" << expected_error << "'\n"
+          << "Received '" << result.error << endl;
+    return false;
+  }
+
+  return true;
 }
 
 bool testParsePublicSuffixTest(

From ad0dab0d74be189edf43051802f5b41e59218d41 Mon Sep 17 00:00:00 2001
From: Peter Snyder <snyderp@gmail.com>
Date: Thu, 28 Feb 2019 14:02:54 -0800
Subject: [PATCH 12/13] remove adding eTLD+1 serilization code into dat, add
 matching tests, FQDN tests

---
 ad_block_client.cc                  |  28 ++----
 etld/internal/public_suffix_rule.cc |   4 +-
 filter.cc                           |   6 +-
 filter.h                            |  12 +--
 test/binding.gyp                    |   1 -
 test/etld_blocking_test.cc          | 134 ----------------------------
 test/etld_serialization_test.cc     | 130 ---------------------------
 test/js/matchingTest.js             | 127 ++++++++++++++++++++------
 8 files changed, 117 insertions(+), 325 deletions(-)
 delete mode 100644 test/etld_serialization_test.cc

diff --git a/ad_block_client.cc b/ad_block_client.cc
index 24aeeb0..640d6f3 100644
--- a/ad_block_client.cc
+++ b/ad_block_client.cc
@@ -1578,7 +1578,7 @@ char * AdBlockClient::serialize(int *totalSize,
   // Get the number of bytes that we'll need
   char sz[512];
   *totalSize += 1 + snprintf(sz, sizeof(sz),
-      "%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x",
+      "%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x",
       numFilters,
       numExceptionFilters, adjustedNumCosmeticFilters, adjustedNumHtmlFilters,
       numNoFingerprintFilters, numNoFingerprintExceptionFilters,
@@ -1594,8 +1594,7 @@ char * AdBlockClient::serialize(int *totalSize,
       noFingerprintDomainHashSetSize,
       noFingerprintAntiDomainHashSetSize,
       noFingerprintDomainExceptionHashSetSize,
-      noFingerprintAntiDomainExceptionHashSetSize,
-      serializedMatcherBufSize);
+      noFingerprintAntiDomainExceptionHashSetSize);
 
   *totalSize += serializeFilters(nullptr, 0, filters, numFilters) +
     serializeFilters(nullptr, 0, exceptionFilters, numExceptionFilters) +
@@ -1704,12 +1703,6 @@ char * AdBlockClient::serialize(int *totalSize,
     delete[] noFingerprintAntiDomainExceptionHashSetBuffer;
   }
 
-  if (serializedMatcherBufSize > 0) {
-    memcpy(buffer + pos, serializedMatcherBuffer.c_str(),
-        serializedMatcherBufSize);
-    pos += serializedMatcherBufSize;
-  }
-
   return buffer;
 }
 
@@ -1760,11 +1753,10 @@ bool AdBlockClient::deserialize(char *buffer) {
       noFingerprintDomainHashSetSize = 0,
       noFingerprintAntiDomainHashSetSize = 0,
       noFingerprintDomainExceptionHashSetSize = 0,
-      noFingerprintAntiDomainExceptionHashSetSize = 0,
-      etldMatcherBufSize = 0;
+      noFingerprintAntiDomainExceptionHashSetSize = 0;
   int pos = 0;
   sscanf(buffer + pos,
-      "%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x",
+      "%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x",
       &numFilters,
       &numExceptionFilters,
       &numCosmeticFilters,
@@ -1784,8 +1776,7 @@ bool AdBlockClient::deserialize(char *buffer) {
       &noFingerprintDomainHashSetSize,
       &noFingerprintAntiDomainHashSetSize,
       &noFingerprintDomainExceptionHashSetSize,
-      &noFingerprintAntiDomainExceptionHashSetSize,
-      &etldMatcherBufSize);
+      &noFingerprintAntiDomainExceptionHashSetSize);
   pos += static_cast<int>(strlen(buffer + pos)) + 1;
 
   filters = new Filter[numFilters];
@@ -1872,15 +1863,6 @@ bool AdBlockClient::deserialize(char *buffer) {
     delete etldMatcher;
   }
 
-  if (etldMatcherBufSize == 0) {
-    etldMatcher = new Matcher();
-  } else {
-    SerializedBuffer serializedmatcherBuffer = std::string(
-      buffer + pos, etldMatcherBufSize);
-    Matcher newMatcher = matcher_from_serialization(serializedmatcherBuffer);
-    etldMatcher = new Matcher(newMatcher);
-  }
-
   return true;
 }
 
diff --git a/etld/internal/public_suffix_rule.cc b/etld/internal/public_suffix_rule.cc
index 5a8392e..09c132d 100644
--- a/etld/internal/public_suffix_rule.cc
+++ b/etld/internal/public_suffix_rule.cc
@@ -199,8 +199,8 @@ PublicSuffixRule rule_from_serialization(const SerializedBuffer& buffer) {
   const bool is_exception = body_str[0] == 't';
   const bool is_wildcard = body_str[1] == 't';
   const string label_str(body_str, 2, info.body_len - 2);
-  const auto label_result = parse_labels(label_str);
-  return {label_result.labels, is_exception, is_wildcard};
+  const PublicSuffixTextLabelsParseResult label_rs = parse_labels(label_str);
+  return {label_rs.labels, is_exception, is_wildcard};
 }
 
 }  // namespace internal
diff --git a/filter.cc b/filter.cc
index 9f05c49..964f66a 100644
--- a/filter.cc
+++ b/filter.cc
@@ -307,7 +307,7 @@ void Filter::parseOption(const char *input, int len) {
     *pFilterOption = static_cast<FilterOption>(*pFilterOption | FOUnknown);
     std::string option(pStart, len);
     if (unknownOptions.find(option) == unknownOptions.end()) {
-      std::cout << "Unrecognized filter option: " << option << std::endl;
+      std::cerr << "Unrecognized filter option: " << option << std::endl;
       unknownOptions.insert(option);
     }
   }
@@ -348,8 +348,8 @@ bool endsWith(const char *input, const char *sub, int inputLen, int subLen) {
   return true;
 }
 
-bool isThirdPartyHost(const char *baseContextHost, int baseContextHostLen,
-    const char *testHost, int testHostLen, Matcher * matcher) {
+bool isThirdPartyHost(const char* baseContextHost, int baseContextHostLen,
+    const char* testHost, int testHostLen, Matcher* matcher) {
   std::string baseDomainStr(baseContextHost, baseContextHostLen);
   Domain baseDomain(baseDomainStr);
   std::string testDomainStr(testHost, testHostLen);
diff --git a/filter.h b/filter.h
index a4d0309..70d94cf 100644
--- a/filter.h
+++ b/filter.h
@@ -204,7 +204,7 @@ friend class AdBlockClient;
   void setEtldMatcher(Matcher * newMatcher) {
     etldMatcher = newMatcher;
   }
-  Matcher * etldMatcher = nullptr;
+  Matcher* etldMatcher = nullptr;
 
  protected:
   // Fills |domains| and |antiDomains| sets
@@ -216,15 +216,15 @@ friend class AdBlockClient;
 };
 
 bool isThirdPartyHost(
-    const char *baseContextHost,
+    const char* baseContextHost,
     int baseContextHostLen,
-    const char *testHost,
+    const char* testHost,
     int testHostLen,
-    Matcher * matcher = nullptr);
+    Matcher* matcher = nullptr);
 
-bool isMatchingHostAnchor(const char *ruleHost,
+bool isMatchingHostAnchor(const char* ruleHost,
     int ruleHostLen,
-    const char *testHost,
+    const char* testHost,
     int testHostLen);
 
 static inline bool isEndOfLine(char c) {
diff --git a/test/binding.gyp b/test/binding.gyp
index 6f02e5b..cace261 100644
--- a/test/binding.gyp
+++ b/test/binding.gyp
@@ -11,7 +11,6 @@
       "../test/protocol_test.cc",
       "../test/orig_filters_test.cc",
       "../test/etld_test.cc",
-      "../test/etld_serialization_test.cc",
       "../test/etld_blocking_test.cc",
       "../test/util.cc",
       "../etld/domain.cc",
diff --git a/test/etld_blocking_test.cc b/test/etld_blocking_test.cc
index f6beef6..e287ff0 100644
--- a/test/etld_blocking_test.cc
+++ b/test/etld_blocking_test.cc
@@ -116,137 +116,3 @@ TEST(etldBlockingTests, basic) {
     third_party_rule,
     true));
 }
-
-bool testAdBlockSerializationWithPublicSuffixList(const string &rules,
-    const string &url, const string &domain, const string &public_suffix_list,
-    const string &expected_rule, bool should_match) {
-  AdBlockClient client;
-  client.parse(rules.c_str(), true);
-  client.parsePublicSuffixRules(public_suffix_list.c_str());
-
-  Filter matching_filter;
-  Filter *matching_ptr = &matching_filter;
-  Filter exception_filter;
-  Filter *exception_ptr = &exception_filter;
-
-  bool one_match = client.findMatchingFilters(url.c_str(), FONoFilterOption,
-    domain.c_str(), &matching_ptr, &exception_ptr);
-
-  // First make sure the first client behaves as expected.
-  if (one_match != should_match) {
-    cout << "Expected " << (should_match ? "a match" : "no match")
-         << " with the first client, but received "
-         << (one_match ? "a match" : "no match") << "." << endl;
-    return false;
-  }
-
-  if (should_match) {
-    bool is_expected_rule = strcmp(
-      matching_ptr->ruleDefinition, expected_rule.c_str()) == 0;
-    if (!is_expected_rule) {
-      cout << "Client one did not return the expected matching rule. "
-           << " Expected '" << expected_rule << "' but received '"
-           << matching_ptr->ruleDefinition << "'" << endl;
-      return false;
-    }
-  }
-
-  // And now build a second client from the de-serialized first, and make sure
-  // they behave the same way.
-  Filter matching_filter2;
-  Filter *matching_ptr2 = &matching_filter2;
-  Filter exception_filter2;
-  Filter *exception_ptr2 = &exception_filter2;
-
-  int size;
-  char* buffer = client.serialize(&size);
-
-  AdBlockClient client2;
-  client2.deserialize(buffer);
-
-  bool two_match = client2.findMatchingFilters(url.c_str(), FONoFilterOption,
-    domain.c_str(), &matching_ptr2, &exception_ptr2);
-
-  if (one_match != two_match) {
-    cout << "Client one matched the filter correctly, but client two "
-         << "returned " << (two_match ? "a match" : "no match")
-         << ". " << endl;
-    return false;
-  }
-
-  if (two_match) {
-    bool returned_rules_match = strncmp(matching_ptr->data,
-      matching_ptr2->data, matching_ptr->dataLen) == 0;
-    if (!returned_rules_match) {
-      cout << "Client two returned differnet rule data ("
-           << string(matching_ptr2->data, matching_ptr2->dataLen)
-           << ") from client one ("
-           << string(matching_ptr->data, matching_ptr->dataLen)
-           << ")." << endl;
-      return false;
-    }
-  }
-
-  return true;
-}
-
-TEST(etldSerializationTests, basic) {
-  ::std::ifstream ifs("./test/data/public_suffix_list.dat");
-  const string public_suffix_rules((::std::istreambuf_iterator<char>(ifs)),
-                                   (::std::istreambuf_iterator<char>()));
-  const string third_party_rule = "||s3.amazonaws.com^$third-party";
-  const string test_url = "http://www.spark-public.s3.amazonaws.com/ads.txt";
-
-  // This should not result in a match, since the rule only applies to
-  // third party domains, and www.spark-public.s3.amazonaws.com
-  // and spark-public.s3.amazonaws.com are eTLD+1 equal (s3.amazonaws.com
-  // is a eTLD).
-  CHECK(testAdBlockSerializationWithPublicSuffixList(
-    third_party_rule,
-    test_url,
-    "spark-public.s3.amazonaws.com",
-    public_suffix_rules,
-    "-ignored-",
-    false));
-
-  // This should match, since spark-public.s3.amazonaws.com
-  // and other.spark-public.s3.amazonaws.com are _not_ eTLD+1 (s3.amazonaws.com
-  // is a eTLD+1).
-  CHECK(testAdBlockSerializationWithPublicSuffixList(
-    third_party_rule,
-    test_url,
-    "other.s3.amazonaws.com",
-    public_suffix_rules,
-    third_party_rule,
-    true));
-
-  // This should match, since the www.spark-public.s3.amazonaws.com
-  // and beans.amazonaws.com are not eTLD+1 (amazonaws.com is not a eTLD).
-  CHECK(testAdBlockSerializationWithPublicSuffixList(
-    third_party_rule,
-    test_url,
-    "beans.amazonaws.com",
-    public_suffix_rules,
-    third_party_rule,
-    true));
-
-  // This should match, since the www.spark-public.s3.amazonaws.com
-  // and example.com are not eTLD+1 (amazonaws.com is not a eTLD).
-  CHECK(testAdBlockSerializationWithPublicSuffixList(
-    third_party_rule,
-    test_url,
-    "example.com",
-    public_suffix_rules,
-    third_party_rule,
-    true));
-
-  // Last, add some non-matching rules, just to make sure we can still
-  // pick out correct rules.
-  CHECK(testAdBlockSerializationWithPublicSuffixList(
-    third_party_rule + "\n||not-matching-anything.com\ntrees^",
-    test_url,
-    "example.com",
-    public_suffix_rules,
-    third_party_rule,
-    true));
-}
diff --git a/test/etld_serialization_test.cc b/test/etld_serialization_test.cc
deleted file mode 100644
index a5c93f3..0000000
--- a/test/etld_serialization_test.cc
+++ /dev/null
@@ -1,130 +0,0 @@
-/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
- * license. This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include <string>
-#include <iostream>
-#include <vector>
-#include <set>
-#include <fstream>
-#include "./CppUnitLite/TestHarness.h"
-#include "./CppUnitLite/Test.h"
-#include "./ad_block_client.h"
-#include "./etld/internal/parser.h"
-#include "./etld/internal/public_suffix_rule.h"
-#include "./etld/internal/public_suffix_rule_set.h"
-#include "./etld/types.h"
-#include "./etld/matcher.h"
-#include "./etld/domain.h"
-#include "./etld/serialization.h"
-
-using ::std::string;
-using ::std::vector;
-using brave_etld::internal::PublicSuffixRule;
-using brave_etld::internal::PublicSuffixRuleSet;
-using brave_etld::internal::rule_from_serialization;
-using brave_etld::internal::rule_set_from_serialization;
-using brave_etld::Matcher;
-using brave_etld::SerializationResult;
-using brave_etld::matcher_from_serialization;
-using brave_etld::SerializedBuffer;
-
-bool testSerializeRule(const string &rule_text) {
-  PublicSuffixRule rule(rule_text);
-  SerializationResult res = rule.Serialize();
-  PublicSuffixRule second_rule = rule_from_serialization(res.buffer);
-  return rule.Equals(second_rule);
-}
-
-TEST(eTLDSerializationSingleRule, basic) {
-  CHECK(testSerializeRule("example.com"));
-  CHECK(testSerializeRule("www.example.com"));
-  CHECK(testSerializeRule("*.example.com"));
-  CHECK(testSerializeRule("!tree.example.com"));
-}
-
-bool testSerializeRuleSet(const vector<PublicSuffixRule> &rules) {
-  PublicSuffixRuleSet rule_set(rules);
-  SerializationResult res = rule_set.Serialize();
-  PublicSuffixRuleSet second_set = rule_set_from_serialization(res.buffer);
-  return rule_set.Equal(second_set);
-}
-
-TEST(eTLDSerializationRuleSet, basic) {
-  CHECK(testSerializeRuleSet({PublicSuffixRule("!one.com")}));
-  CHECK(testSerializeRuleSet({
-    PublicSuffixRule("!one.com"), PublicSuffixRule("*.two.com")}));
-  CHECK(testSerializeRuleSet({
-    PublicSuffixRule("!one.com"), PublicSuffixRule("*.two.com"),
-    PublicSuffixRule("three.com")}));
-}
-
-bool testSerializeMatcher(const string &rule_text) {
-  Matcher orig(rule_text);
-  SerializationResult res = orig.Serialize();
-  Matcher second = matcher_from_serialization(res.buffer);
-  return orig.Equal(second);
-}
-
-TEST(eTLDSerializationMatcher, basic) {
-  CHECK(testSerializeMatcher("!one.com"));
-  CHECK(testSerializeMatcher("!one.com\n*.two.com"));
-  CHECK(testSerializeMatcher("!one.com\n*.two.com\nthree.com"));
-}
-
-bool testMatcherSerializationTransitivity(const string &public_suffix_rules) {
-  Matcher orig(public_suffix_rules);
-  SerializationResult res = orig.Serialize();
-
-  Matcher second = matcher_from_serialization(res.buffer);
-  SerializationResult res2 = second.Serialize();
-
-  if (res2.buffer.compare(res.buffer) != 0) {
-    std::cout << "The serialized buffer of the initial Matcher does not match "
-              << "the serialized of the second, buffer initialized buffer."
-              << std::endl;
-    return false;
-  }
-
-  return true;
-}
-
-bool testAdBlockClientSerializationTransitivity(const string &filter_rules,
-    const string &public_suffix_rules) {
-  AdBlockClient client;
-  client.parse(filter_rules.c_str());
-  client.parsePublicSuffixRules(public_suffix_rules.c_str());
-
-  int size;
-  char* buffer = client.serialize(&size);
-
-  AdBlockClient client2;
-  client2.deserialize(buffer);
-  int size2;
-  char* buffer2 = client2.serialize(&size2);
-
-  if (size != size2) {
-    std::cout << "The size of the serialized buffers of the first and second "
-              << "client do not match." << std::endl;
-    return false;
-  }
-
-  if (strncmp(buffer, buffer2, size) != 0) {
-    std::cout << "The serialized buffers of the first and second client do "
-              << "not have the same contents." << std::endl;
-    return false;
-  }
-
-  return true;
-}
-
-TEST(eTLDSerializationTransitivity, basic) {
-  std::ifstream ifs("./test/data/public_suffix_list_short.txt");
-  const string public_suffix_rules((std::istreambuf_iterator<char>(ifs)),
-                                   (std::istreambuf_iterator<char>()));
-  const string filer_rules = "||not-matching-anything.com\ntrees^";
-  CHECK(testMatcherSerializationTransitivity(public_suffix_rules));
-  CHECK(testAdBlockClientSerializationTransitivity(
-    filer_rules, public_suffix_rules));
-}
diff --git a/test/js/matchingTest.js b/test/js/matchingTest.js
index fb0ad3c..a532ddf 100644
--- a/test/js/matchingTest.js
+++ b/test/js/matchingTest.js
@@ -458,35 +458,110 @@ describe('matching', function () {
   })
 
   describe('third-party match', function () {
-    before(function () {
-      this.client = new AdBlockClient()
-      this.client.parse('||bannersnack.com^$third-party')
-      const etldRules = fs.readFileSync('./test/data/public_suffix_list.dat', 'utf8')
-      this.client.parsePublicSuffixRules(etldRules)
-    })
-    it('consider eTLD+1 domains as 1p', function () {
-      const altSubDomainQuery = this.client.findMatchingFilters(
-        'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
-        FilterOptions.script,
-        'www.bannersnack.com'
-      )
-      assert.equal(altSubDomainQuery.matches, false)
+    describe('when parsing public suffix list', function () {
+      before(function () {
+        this.client = new AdBlockClient()
+        this.client.parse('||bannersnack.com^$third-party')
+        const etldRules = fs.readFileSync('./test/data/public_suffix_list.dat', 'utf8')
+        this.client.parsePublicSuffixRules(etldRules)
+      })
+      it('eTLD+1 should not be3p', function () {
+        const altSummaryResult = this.client.matches(
+          'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
+          FilterOptions.script,
+          'www.bannersnack.com'
+        )
+        assert.equal(altSummaryResult, false)
+
+        const altSubDomainQuery = this.client.findMatchingFilters(
+          'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
+          FilterOptions.script,
+          'www.bannersnack.com'
+        )
+        assert.equal(altSubDomainQuery.matches, false)
+
+        const bareDomainRs = this.client.matches(
+          'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
+          FilterOptions.script,
+          'bannersnack.com'
+        )
+        assert.equal(bareDomainRs, false)
 
-      const bareDomainQuery = this.client.findMatchingFilters(
-        'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
-        FilterOptions.script,
-        'bannersnack.com'
-      )
-      assert.equal(bareDomainQuery.matches, false)
+        const bareDomainQuery = this.client.findMatchingFilters(
+          'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
+          FilterOptions.script,
+          'bannersnack.com'
+        )
+        assert.equal(bareDomainQuery.matches, false)
+      })
+
+      it('consider non eTLD+1 domains as 3p', function () {
+        const matchesRs = this.client.matches(
+          'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
+          FilterOptions.script,
+          'www.example.org'
+        )
+        assert.equal(matchesRs, true)
+
+        const queryResult = this.client.findMatchingFilters(
+          'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
+          FilterOptions.script,
+          'www.example.org'
+        )
+        assert.equal(queryResult.matches, true)
+      })
     })
 
-    it('consider non eTLD+1 domains as 3p', function () {
-      const queryResult = this.client.findMatchingFilters(
-        'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
-        FilterOptions.script,
-        'www.example.org'
-      )
-      assert.equal(queryResult.matches, true)
+    describe('when falling back to FQDN', function () {
+      before(function () {
+        this.client = new AdBlockClient()
+        this.client.parse('||bannersnack.com^$third-party')
+      })
+      it('eTLD+1 domains should be 3p', function () {
+        const altSummaryResult = this.client.matches(
+          'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
+          FilterOptions.script,
+          'www.bannersnack.com'
+        )
+        assert.equal(altSummaryResult, true)
+
+        const altSubDomainQuery = this.client.findMatchingFilters(
+          'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
+          FilterOptions.script,
+          'www.bannersnack.com'
+        )
+        assert.equal(altSubDomainQuery.matches, true)
+
+        const bareDomainRs = this.client.matches(
+          'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
+          FilterOptions.script,
+          'bannersnack.com'
+        )
+        assert.equal(bareDomainRs, true)
+
+        const bareDomainQuery = this.client.findMatchingFilters(
+          'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
+          FilterOptions.script,
+          'bannersnack.com'
+        )
+        assert.equal(bareDomainQuery.matches, true)
+      })
+
+      it('non-eTLD+1 should still be 3p', function () {
+        const matchesRs = this.client.matches(
+          'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
+          FilterOptions.script,
+          'www.example.org'
+        )
+        assert.equal(matchesRs, true)
+
+        const queryResult = this.client.findMatchingFilters(
+          'https://cdn.bannersnack.com/public/texts/en.js?v=6.10.16',
+          FilterOptions.script,
+          'www.example.org'
+        )
+        assert.equal(queryResult.matches, true)
+      })
     })
   })
 })

From 7ec14d785a93309a052e46cf0e43ac8a849f15e1 Mon Sep 17 00:00:00 2001
From: Peter Snyder <snyderp@gmail.com>
Date: Thu, 28 Feb 2019 14:09:40 -0800
Subject: [PATCH 13/13] restore serialization code

---
 ad_block_client.cc              |  28 +++++--
 test/binding.gyp                |   1 +
 test/etld_blocking_test.cc      | 134 ++++++++++++++++++++++++++++++++
 test/etld_serialization_test.cc | 130 +++++++++++++++++++++++++++++++
 4 files changed, 288 insertions(+), 5 deletions(-)
 create mode 100644 test/etld_serialization_test.cc

diff --git a/ad_block_client.cc b/ad_block_client.cc
index 640d6f3..24aeeb0 100644
--- a/ad_block_client.cc
+++ b/ad_block_client.cc
@@ -1578,7 +1578,7 @@ char * AdBlockClient::serialize(int *totalSize,
   // Get the number of bytes that we'll need
   char sz[512];
   *totalSize += 1 + snprintf(sz, sizeof(sz),
-      "%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x",
+      "%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x",
       numFilters,
       numExceptionFilters, adjustedNumCosmeticFilters, adjustedNumHtmlFilters,
       numNoFingerprintFilters, numNoFingerprintExceptionFilters,
@@ -1594,7 +1594,8 @@ char * AdBlockClient::serialize(int *totalSize,
       noFingerprintDomainHashSetSize,
       noFingerprintAntiDomainHashSetSize,
       noFingerprintDomainExceptionHashSetSize,
-      noFingerprintAntiDomainExceptionHashSetSize);
+      noFingerprintAntiDomainExceptionHashSetSize,
+      serializedMatcherBufSize);
 
   *totalSize += serializeFilters(nullptr, 0, filters, numFilters) +
     serializeFilters(nullptr, 0, exceptionFilters, numExceptionFilters) +
@@ -1703,6 +1704,12 @@ char * AdBlockClient::serialize(int *totalSize,
     delete[] noFingerprintAntiDomainExceptionHashSetBuffer;
   }
 
+  if (serializedMatcherBufSize > 0) {
+    memcpy(buffer + pos, serializedMatcherBuffer.c_str(),
+        serializedMatcherBufSize);
+    pos += serializedMatcherBufSize;
+  }
+
   return buffer;
 }
 
@@ -1753,10 +1760,11 @@ bool AdBlockClient::deserialize(char *buffer) {
       noFingerprintDomainHashSetSize = 0,
       noFingerprintAntiDomainHashSetSize = 0,
       noFingerprintDomainExceptionHashSetSize = 0,
-      noFingerprintAntiDomainExceptionHashSetSize = 0;
+      noFingerprintAntiDomainExceptionHashSetSize = 0,
+      etldMatcherBufSize = 0;
   int pos = 0;
   sscanf(buffer + pos,
-      "%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x",
+      "%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x",
       &numFilters,
       &numExceptionFilters,
       &numCosmeticFilters,
@@ -1776,7 +1784,8 @@ bool AdBlockClient::deserialize(char *buffer) {
       &noFingerprintDomainHashSetSize,
       &noFingerprintAntiDomainHashSetSize,
       &noFingerprintDomainExceptionHashSetSize,
-      &noFingerprintAntiDomainExceptionHashSetSize);
+      &noFingerprintAntiDomainExceptionHashSetSize,
+      &etldMatcherBufSize);
   pos += static_cast<int>(strlen(buffer + pos)) + 1;
 
   filters = new Filter[numFilters];
@@ -1863,6 +1872,15 @@ bool AdBlockClient::deserialize(char *buffer) {
     delete etldMatcher;
   }
 
+  if (etldMatcherBufSize == 0) {
+    etldMatcher = new Matcher();
+  } else {
+    SerializedBuffer serializedmatcherBuffer = std::string(
+      buffer + pos, etldMatcherBufSize);
+    Matcher newMatcher = matcher_from_serialization(serializedmatcherBuffer);
+    etldMatcher = new Matcher(newMatcher);
+  }
+
   return true;
 }
 
diff --git a/test/binding.gyp b/test/binding.gyp
index cace261..6f02e5b 100644
--- a/test/binding.gyp
+++ b/test/binding.gyp
@@ -11,6 +11,7 @@
       "../test/protocol_test.cc",
       "../test/orig_filters_test.cc",
       "../test/etld_test.cc",
+      "../test/etld_serialization_test.cc",
       "../test/etld_blocking_test.cc",
       "../test/util.cc",
       "../etld/domain.cc",
diff --git a/test/etld_blocking_test.cc b/test/etld_blocking_test.cc
index e287ff0..f6beef6 100644
--- a/test/etld_blocking_test.cc
+++ b/test/etld_blocking_test.cc
@@ -116,3 +116,137 @@ TEST(etldBlockingTests, basic) {
     third_party_rule,
     true));
 }
+
+bool testAdBlockSerializationWithPublicSuffixList(const string &rules,
+    const string &url, const string &domain, const string &public_suffix_list,
+    const string &expected_rule, bool should_match) {
+  AdBlockClient client;
+  client.parse(rules.c_str(), true);
+  client.parsePublicSuffixRules(public_suffix_list.c_str());
+
+  Filter matching_filter;
+  Filter *matching_ptr = &matching_filter;
+  Filter exception_filter;
+  Filter *exception_ptr = &exception_filter;
+
+  bool one_match = client.findMatchingFilters(url.c_str(), FONoFilterOption,
+    domain.c_str(), &matching_ptr, &exception_ptr);
+
+  // First make sure the first client behaves as expected.
+  if (one_match != should_match) {
+    cout << "Expected " << (should_match ? "a match" : "no match")
+         << " with the first client, but received "
+         << (one_match ? "a match" : "no match") << "." << endl;
+    return false;
+  }
+
+  if (should_match) {
+    bool is_expected_rule = strcmp(
+      matching_ptr->ruleDefinition, expected_rule.c_str()) == 0;
+    if (!is_expected_rule) {
+      cout << "Client one did not return the expected matching rule. "
+           << " Expected '" << expected_rule << "' but received '"
+           << matching_ptr->ruleDefinition << "'" << endl;
+      return false;
+    }
+  }
+
+  // And now build a second client from the de-serialized first, and make sure
+  // they behave the same way.
+  Filter matching_filter2;
+  Filter *matching_ptr2 = &matching_filter2;
+  Filter exception_filter2;
+  Filter *exception_ptr2 = &exception_filter2;
+
+  int size;
+  char* buffer = client.serialize(&size);
+
+  AdBlockClient client2;
+  client2.deserialize(buffer);
+
+  bool two_match = client2.findMatchingFilters(url.c_str(), FONoFilterOption,
+    domain.c_str(), &matching_ptr2, &exception_ptr2);
+
+  if (one_match != two_match) {
+    cout << "Client one matched the filter correctly, but client two "
+         << "returned " << (two_match ? "a match" : "no match")
+         << ". " << endl;
+    return false;
+  }
+
+  if (two_match) {
+    bool returned_rules_match = strncmp(matching_ptr->data,
+      matching_ptr2->data, matching_ptr->dataLen) == 0;
+    if (!returned_rules_match) {
+      cout << "Client two returned differnet rule data ("
+           << string(matching_ptr2->data, matching_ptr2->dataLen)
+           << ") from client one ("
+           << string(matching_ptr->data, matching_ptr->dataLen)
+           << ")." << endl;
+      return false;
+    }
+  }
+
+  return true;
+}
+
+TEST(etldSerializationTests, basic) {
+  ::std::ifstream ifs("./test/data/public_suffix_list.dat");
+  const string public_suffix_rules((::std::istreambuf_iterator<char>(ifs)),
+                                   (::std::istreambuf_iterator<char>()));
+  const string third_party_rule = "||s3.amazonaws.com^$third-party";
+  const string test_url = "http://www.spark-public.s3.amazonaws.com/ads.txt";
+
+  // This should not result in a match, since the rule only applies to
+  // third party domains, and www.spark-public.s3.amazonaws.com
+  // and spark-public.s3.amazonaws.com are eTLD+1 equal (s3.amazonaws.com
+  // is a eTLD).
+  CHECK(testAdBlockSerializationWithPublicSuffixList(
+    third_party_rule,
+    test_url,
+    "spark-public.s3.amazonaws.com",
+    public_suffix_rules,
+    "-ignored-",
+    false));
+
+  // This should match, since spark-public.s3.amazonaws.com
+  // and other.spark-public.s3.amazonaws.com are _not_ eTLD+1 (s3.amazonaws.com
+  // is a eTLD+1).
+  CHECK(testAdBlockSerializationWithPublicSuffixList(
+    third_party_rule,
+    test_url,
+    "other.s3.amazonaws.com",
+    public_suffix_rules,
+    third_party_rule,
+    true));
+
+  // This should match, since the www.spark-public.s3.amazonaws.com
+  // and beans.amazonaws.com are not eTLD+1 (amazonaws.com is not a eTLD).
+  CHECK(testAdBlockSerializationWithPublicSuffixList(
+    third_party_rule,
+    test_url,
+    "beans.amazonaws.com",
+    public_suffix_rules,
+    third_party_rule,
+    true));
+
+  // This should match, since the www.spark-public.s3.amazonaws.com
+  // and example.com are not eTLD+1 (amazonaws.com is not a eTLD).
+  CHECK(testAdBlockSerializationWithPublicSuffixList(
+    third_party_rule,
+    test_url,
+    "example.com",
+    public_suffix_rules,
+    third_party_rule,
+    true));
+
+  // Last, add some non-matching rules, just to make sure we can still
+  // pick out correct rules.
+  CHECK(testAdBlockSerializationWithPublicSuffixList(
+    third_party_rule + "\n||not-matching-anything.com\ntrees^",
+    test_url,
+    "example.com",
+    public_suffix_rules,
+    third_party_rule,
+    true));
+}
diff --git a/test/etld_serialization_test.cc b/test/etld_serialization_test.cc
new file mode 100644
index 0000000..a5c93f3
--- /dev/null
+++ b/test/etld_serialization_test.cc
@@ -0,0 +1,130 @@
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <string>
+#include <iostream>
+#include <vector>
+#include <set>
+#include <fstream>
+#include "./CppUnitLite/TestHarness.h"
+#include "./CppUnitLite/Test.h"
+#include "./ad_block_client.h"
+#include "./etld/internal/parser.h"
+#include "./etld/internal/public_suffix_rule.h"
+#include "./etld/internal/public_suffix_rule_set.h"
+#include "./etld/types.h"
+#include "./etld/matcher.h"
+#include "./etld/domain.h"
+#include "./etld/serialization.h"
+
+using ::std::string;
+using ::std::vector;
+using brave_etld::internal::PublicSuffixRule;
+using brave_etld::internal::PublicSuffixRuleSet;
+using brave_etld::internal::rule_from_serialization;
+using brave_etld::internal::rule_set_from_serialization;
+using brave_etld::Matcher;
+using brave_etld::SerializationResult;
+using brave_etld::matcher_from_serialization;
+using brave_etld::SerializedBuffer;
+
+bool testSerializeRule(const string &rule_text) {
+  PublicSuffixRule rule(rule_text);
+  SerializationResult res = rule.Serialize();
+  PublicSuffixRule second_rule = rule_from_serialization(res.buffer);
+  return rule.Equals(second_rule);
+}
+
+TEST(eTLDSerializationSingleRule, basic) {
+  CHECK(testSerializeRule("example.com"));
+  CHECK(testSerializeRule("www.example.com"));
+  CHECK(testSerializeRule("*.example.com"));
+  CHECK(testSerializeRule("!tree.example.com"));
+}
+
+bool testSerializeRuleSet(const vector<PublicSuffixRule> &rules) {
+  PublicSuffixRuleSet rule_set(rules);
+  SerializationResult res = rule_set.Serialize();
+  PublicSuffixRuleSet second_set = rule_set_from_serialization(res.buffer);
+  return rule_set.Equal(second_set);
+}
+
+TEST(eTLDSerializationRuleSet, basic) {
+  CHECK(testSerializeRuleSet({PublicSuffixRule("!one.com")}));
+  CHECK(testSerializeRuleSet({
+    PublicSuffixRule("!one.com"), PublicSuffixRule("*.two.com")}));
+  CHECK(testSerializeRuleSet({
+    PublicSuffixRule("!one.com"), PublicSuffixRule("*.two.com"),
+    PublicSuffixRule("three.com")}));
+}
+
+bool testSerializeMatcher(const string &rule_text) {
+  Matcher orig(rule_text);
+  SerializationResult res = orig.Serialize();
+  Matcher second = matcher_from_serialization(res.buffer);
+  return orig.Equal(second);
+}
+
+TEST(eTLDSerializationMatcher, basic) {
+  CHECK(testSerializeMatcher("!one.com"));
+  CHECK(testSerializeMatcher("!one.com\n*.two.com"));
+  CHECK(testSerializeMatcher("!one.com\n*.two.com\nthree.com"));
+}
+
+bool testMatcherSerializationTransitivity(const string &public_suffix_rules) {
+  Matcher orig(public_suffix_rules);
+  SerializationResult res = orig.Serialize();
+
+  Matcher second = matcher_from_serialization(res.buffer);
+  SerializationResult res2 = second.Serialize();
+
+  if (res2.buffer.compare(res.buffer) != 0) {
+    std::cout << "The serialized buffer of the initial Matcher does not match "
+              << "the serialized of the second, buffer initialized buffer."
+              << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
+bool testAdBlockClientSerializationTransitivity(const string &filter_rules,
+    const string &public_suffix_rules) {
+  AdBlockClient client;
+  client.parse(filter_rules.c_str());
+  client.parsePublicSuffixRules(public_suffix_rules.c_str());
+
+  int size;
+  char* buffer = client.serialize(&size);
+
+  AdBlockClient client2;
+  client2.deserialize(buffer);
+  int size2;
+  char* buffer2 = client2.serialize(&size2);
+
+  if (size != size2) {
+    std::cout << "The size of the serialized buffers of the first and second "
+              << "client do not match." << std::endl;
+    return false;
+  }
+
+  if (strncmp(buffer, buffer2, size) != 0) {
+    std::cout << "The serialized buffers of the first and second client do "
+              << "not have the same contents." << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
+TEST(eTLDSerializationTransitivity, basic) {
+  std::ifstream ifs("./test/data/public_suffix_list_short.txt");
+  const string public_suffix_rules((std::istreambuf_iterator<char>(ifs)),
+                                   (std::istreambuf_iterator<char>()));
+  const string filer_rules = "||not-matching-anything.com\ntrees^";
+  CHECK(testMatcherSerializationTransitivity(public_suffix_rules));
+  CHECK(testAdBlockClientSerializationTransitivity(
+    filer_rules, public_suffix_rules));
+}